BZOJ2338 [HNOI2011]数矩形

恩。。。什么神题，表示不会。。。

然后各种乱搞，发现最坏都是O(n ^ 4)的复杂度：

做法即暴力，求出所有对角线

查看那些能构成矩形的对角线，即长度和中点都相同的线段，算一下面积即可。

后来看了看各种题解，都是这么做的。。。真的不会被卡嘛= =

蒟蒻也只好这么乱搞了

话说貌似想到了一种O(n ^ 2 * log(n ^ 2))的做法？

就是线段排好序以后，查看那些长度和中点都相同的的对角线，按照极角排序

由凸包旋转卡壳的思想，去除排序复杂度，是可以做到O（线段个数）的。

好烦。。。不想写的说>_<

/**************************************************************
    Problem: 2338
    User: rausen
    Language: C++
    Result: Accepted
    Time:1808 ms
    Memory:36224 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
 
#define P Point
#define L Line
using namespace std;
typedef long long ll;
const int N = 1505;
const int M = N * N >> 1;
 
int n, tot;
ll ans;
 
struct Point {
    ll x, y;
    P() {}
    P(ll _x, ll _y) : x(_x), y(_y) {}
     
    inline bool operator == (const P &b) const {
        return x == b.x && y == b.y;
    }
    inline bool operator < (const P &b) const {
        return x == b.x ? y < b.y : x < b.x;
    }
    inline P operator + (const P &b) const {
        return P(x + b.x, y + b.y);
    }
    inline P operator - (const P &b) const {
        return P(x - b.x, y - b.y);
    }
    inline ll operator * (const P &b) const {
        return x * b.y - y * b.x;
    }
} a[N];
 
struct Line {
    int a, b;
    ll len;
    P mid;
    L() {}
    L(int _a, int _b, ll _l, P _m) : a(_a), b(_b), len(_l), mid(_m) {}
     
    inline bool operator == (const L &b) const {
        return len == b.len && mid == b.mid;
    }
    inline bool operator < (const L &b) const {
        return len == b.len ? mid < b.mid : len < b.len;
    }
} l[M];
 
inline ll read() {
    ll x = 0, sgn = 1;
    char ch = getchar();
    while (ch < '0' || '9' < ch) {
        if (ch == '-') sgn = -1;
        ch = getchar();
    }
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return sgn * x;
}
 
inline ll sqr(ll x) {
    return (ll) x * x;
}
 
inline ll dist(P a, P b) {
    return (ll) sqr(a.x - b.x) + sqr(a.y - b.y);
}
 
inline ll abs_ll(ll x) {
    return x < 0 ? -x : x;
}
 
int main() {
    int i, j;
    n = read();
    for (i = 1; i <= n; ++i)
        a[i].x = read(), a[i].y = read();
    for (i = 1; i < n; ++i)
        for (j = i + 1; j <= n; ++j)
            l[++tot] = L(i, j, dist(a[i], a[j]), a[i] + a[j]);
    sort(l + 1, l + tot + 1);
    for (i = 1; i <= tot; ++i)
        for (j = i - 1; j && l[i] == l[j]; --j)
            ans = max(ans, abs_ll((a[l[i].a] - a[l[j].a]) * (a[l[i].a] - a[l[j].b])));
    printf("%lld
", ans);
    return 0;
}