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
;

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\n", ans);
return 0;
}

View Code