BZOJ3707 圈地

只会O(n ^ 3)路过= =

OrzOrzOrzOrzOrz

"出题人题解：

显然，这时候暴力枚举会T。于是我们转变一下思路，如果我们确定了2个点以后，第三个点有必要去盲目的枚举吗？答案是否定的。实际上我们把经过这两点的线看成一个斜率，把他当成y轴你会发现第三个点明显是在坐标系左右找一个离”y轴”最近的点来算面积更新答案。然后我们可以继续思考，发现我们可以把点按照某个斜率当成”y轴”进行“从左到右”的排序，这样当2点共线的时候，用这两个点的左右2个点去更新答案就好了。也就是说我们采用旋转坐标系的方法，一开始按x坐标排好序，认为直接用竖着的那条斜率，然后维护的话每次其实当两点共线后只要交换他们就能得到斜率转过该事件点的序列。所以我们可以预处理出所有可行的斜率，当成事件点，不断转动坐标系更新答案就好。这样复杂度只有n^2，期望得分100.(这确实只是个暴力的优化 啊。。。不要砸我T_T)"

 /**************************************************************
     Problem: 3707
     User: rausen
     Language: C++
     Result: Accepted
     Time:576 ms
     Memory:16616 kb
 ****************************************************************/

 #include <cstdio>
 #include <cmath>
 #include <algorithm>

 using namespace std;
 typedef double lf;
 const int N = ;
 const int M = N * N;

 struct points {
     lf x, y;
     points() {}
     points(lf _x, lf _y) : x(_x), y(_y) {}
 }p[N];
 inline bool operator < (const points &a, const points &b) {
     return a.x < b.x;
 }

 inline points operator - (const points &a, const points &b) {
     return points(a.x - b.x, a.y - b.y);
 }

 inline lf operator & (const points &a, const points &b) {
     return a.x * b.y - a.y * b.x;
 }

 struct lines {
     int p1, p2;
     lf S;
     lines() {}
     lines(int _p1, int _p2, lf _S) : p1(_p1), p2(_p2), S(_S) {}
 }l[M];
 inline bool operator < (const lines &a, const lines &b) {
     return a.S < b.S;
 }

 int n, tot;
 int w[N], a[N];
 lf ans = 1e60;

 inline int read() {
     int x = , sgn = ;
     char ch = getchar();
     while (ch < '' || '' < ch) {
         if (ch == '-') sgn = -;
         ch = getchar();
     }
     while ('' <= ch && ch <= '') {
         x = x *  + ch - '';
         ch = getchar();
     }
     return sgn * x;
 }

 inline void calc(int i, int j, int k) {
     ans = min(ans, fabs((p[i] - p[k]) & (p[j] - p[k])) / );
 }

 int main() {
     int i, j, p1, p2;
     n = read();
     for (i = ; i <= n; ++i)
         p[i].x = read(), p[i].y = read();
     sort(p + , p + n + );
     for (i = ; i <= n; ++i)
         a[i] = w[i] = i;
     for (i = ; i <= n; ++i)
         for (j = i + ; j <= n; ++j)
             l[++tot] = lines(i, j, (p[j].y - p[i].y) / (p[j].x - p[i].x));
     sort(l + , l + tot + );
     for (i = ; i <= tot; ++i) {
         p1 = l[i].p1, p2 = l[i].p2;
         if (w[p1] > w[p2]) swap(p1, p2);
         if (w[p1] > ) calc(a[w[p1] - ], p1, p2);
         if (w[p2] < n) calc(a[w[p2] + ], p1, p2);
         swap(w[p1], w[p2]);
         swap(a[w[p1]], a[w[p2]]);
     }
     printf("%.2lf\n", ans);
     return ;
 }

（p.s. 话说那些Rank前4是怎么做到的= =内存和时间都很小的说Orz）