ZOJ2347 Squares （POJ2002 二分查找）

给 N 个点，任意取其中4个，是否能构成正方形，能的话算一组，求有多少组这样的点，也就是说最多可以找出多少个正方形
方法很简单，确定两个点，必然可以求出正方形的另外两个点，在点集中查找，另外两个点是否存在就可以了。用二分查找，中间加上剪枝，时间可以压到 1s 一下，但是那些 100ms+ 的神人是怎么做到的，就不得而知了……无限Orz……
PS: ZOJ 和 POJ 输入输出格式不太一样，注意啊，好坑爹的……

递归版二分查找，最慢的一种了， ZOJ 跑了4800ms+ 才过，POJ 直接 TL ，掩面啊，泪奔啊……
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
#define N 1005

struct point
{
double x,y;
};
point p
;
int n;

bool operator ==(point a,point b)//运算符重载
{
if( a.x==b.x && a.y==b.y )return true;
return false;
}
bool operator >(point a,point b)
{
if(a.x>b.x || a.x==b.x && a.y>b.y)return true;
return false;
}
bool operator <(point a,point b)
{
if(a.x<b.x || a.x==b.x && a.y<b.y)return true;
return false;
}

int cmp(const void *a,const void *b)
{
return *(point *)a > *(point *)b ? 1:-1;
}

int find(point p[],int low,int high,point v)//递归的二分
{
if(low==high)return -1;
if(p[low] == v)return low;
if(p[high] == v)return high;
int mid=(low+high)/2;
if( p[mid] == v ) return mid;
if( v > p[mid] ) return find(p,mid+1,high,v);
return find(p,low,mid,v);
}

point Whirl(double cosl, double sinl, point a, point b)
// ab 绕 a 逆时针转过角度 A 得到的点,sinl=sinA,cosl=cosA
{
b.x -= a.x; b.y -= a.y;
point c;
c.x = b.x * cosl - b.y * sinl + a.x;
c.y = b.x * sinl + b.y * cosl + a.y;
return c;
}

int judge(int i,int j)
{
point pa,pb,po;
if(i==j)return 0;
po.x=(p[i].x+p[j].x)/2.0;
po.y=(p[i].y+p[j].y)/2.0;
pa=Whirl(0.0,1.0,po,p[i]);//逆时针90度旋转
pb=Whirl(0.0,1.0,po,p[j]);//顺时针旋转
if(find(p,0,n,pa)==-1) return 0;
else if(find(p,0,n,pb)==-1) return 0;
return 1;
}

int main()
{
int t,i,j;
scanf("%d",&t);
while(t--)
{
while(scanf("%d",&n),n)
{
for(i=0;i<n;i++)
scanf("%lf%lf",&p[i].x,&p[i].y);

qsort(p,n,sizeof(p[0]),cmp);

int cnt=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
if(judge(i,j)==1)cnt++;
}
printf("%d\n",cnt/2);
}
if(t)puts("");
}
return 0;
}
后来看人家的二分查找都用 while() 整，换了下，快好多，ZOJ 是 3400ms+ ，POJ 跑了 2900ms+
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
#define N 1005

struct point
{
double x,y;
};
point p
;
int n;

bool operator ==(point a,point b)//运算符重载
{
if( a.x==b.x && a.y==b.y )return true;
return false;
}
bool operator >(point a,point b)
{
if(a.x>b.x || a.x==b.x && a.y>b.y)return true;
return false;
}
bool operator <(point a,point b)
{
if(a.x<b.x || a.x==b.x && a.y<b.y)return true;
return false;
}

int cmp(const void *a,const void *b)
{
return *(point *)a > *(point *)b ? 1:-1;
}
bool find(point a,int m)
{
int begin = 0,end = m-1;
while( begin <= end )
{
int mid = ( begin + end )/2;
if( a.x==p[mid].x && a.y==p[mid].y )return true;
if( a.x>p[mid].x || a.x==p[mid].x && a.y>p[mid].y )
begin = mid + 1;
else end = mid - 1;
}
return false;
}

point Whirl(double cosl, double sinl, point a, point b)
// ab 绕 a 逆时针转过角度 A 得到的点,sinl=sinA,cosl=cosA
{
b.x -= a.x; b.y -= a.y;
point c;
c.x = b.x * cosl - b.y * sinl + a.x;
c.y = b.x * sinl + b.y * cosl + a.y;
return c;
}

int judge(int i,int j)
{
point pa,pb,po;
if(i==j)return 0;
po.x=(p[i].x+p[j].x)/2.0;
po.y=(p[i].y+p[j].y)/2.0;
pa=Whirl(0.0,1.0,po,p[i]);//逆时针90度旋转
pb=Whirl(0.0,1.0,po,p[j]);//顺时针旋转
if(!find(pa,n)) return 0;
else if(!find(pb,n)) return 0;
return 1;
}

int main()
{
int i,j;
while(scanf("%d",&n),n)
{
for(i=0;i<n;i++)
scanf("%lf%lf",&p[i].x,&p[i].y);

qsort(p,n,sizeof(p[0]),cmp);

int cnt=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
if(judge(i,j)==1)cnt++;
}
printf("%d\n",cnt/2);
}
return 0;
}
也有人用 STL 里面的二分，也挺快的，然后人又加了个剪枝，正方形只算一遍，直接压到 1000ms 左右，贴下学习下
#include <iostream>
#include <algorithm>
#include <cstdio>

using namespace std;
struct node
{
int x, y;
} p[1001];
bool op(node xx,node yy)
{
if (xx.x == yy.x)
return xx.y < yy.y;
else return xx.x < yy.x;
}
int main()
{
int points;
while (scanf("%d", &points), points)
{
int sum = 0;
for (int k = 0; k < points; ++k)
scanf("%d%d", &p[k].x, &p[k].y);
sort(p, p + points, op);
for (int i = 0; i < points; ++i)
{
for (int j = i + 1; j < points; ++j)
{
if(p[i].x <= p[j].x && p[i].y >= p[j].y)
{
node p0, p1;
p0.x = p[i].x + p[j].y - p[i].y;
p0.y = p[i].y + p[i].x - p[j].x;
p1.x = p[j].x + p[j].y - p[i].y;
p1.y = p[j].y + p[i].x - p[j].x;
if (!binary_search(p, p+points, p0, op))
continue;
if (!binary_search(p, p+points, p1, op))
continue;
sum++;
}
}
}
printf("%d\n", sum);
}
return 0;
}