Day3-I-Squares POJ2002

 

A square is a 4-sided polygon whose sides have equal length and adjacent sides form 90-degree angles. It is also a polygon such that rotating about its centre by 90 degrees gives the same polygon. It is not the only polygon with the latter property, however, as a regular octagon also has this property. 

So we all know what a square looks like, but can we find all possible squares that can be formed from a set of stars in a night sky? To make the problem easier, we will assume that the night sky is a 2-dimensional plane, and each star is specified by its x and y coordinates. 

Input

The input consists of a number of test cases. Each test case starts with the integer n (1 <= n <= 1000) indicating the number of points to follow. Each of the next n lines specify the x and y coordinates (two integers) of each point. You may assume that the points are distinct and the magnitudes of the coordinates are less than 20000. The input is terminated when n = 0.

Output

For each test case, print on a line the number of squares one can form from the given stars.

Sample Input

4
1 0
0 1
1 1
0 0
9
0 0
1 0
2 0
0 2
1 2
2 2
0 1
1 1
2 1
4
-2 5
3 7
0 0
5 2
0

Sample Output

1
6
1

 思路：一个正方形的四个顶点可由2个来算出，枚举这两个点，然后搜索剩下的点，O(N^2logN)，如图：
  

  　此时枚举x1,x2，x3 = x2+-(y1-y2), y3 = y2+-(x1-x2), x4,y4同理，代码如下：

const int maxm = 1010;

struct Node {
    int x, y;

    bool operator<(const Node &a)const {
        return x < a.x || (x == a.x && y < a.y);
    }
} buf[maxm];

int n;

int main() {
    while(scanf("%d",&n) != EOF && n) {
        int ans = 0;
        Node t1, t2;
        for (int i = 0; i < n; ++i) {
            scanf("%d%d", &buf[i].x, &buf[i].y);
        }
        sort(buf, buf + n);
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; ++j) {
                t1.x = buf[j].x + (buf[i].y - buf[j].y);
                t1.y = buf[j].y - (buf[i].x - buf[j].x);
                t2.x = buf[i].x + (buf[i].y - buf[j].y);
                t2.y = buf[i].y - (buf[i].x - buf[j].x);
                if(binary_search(buf,buf+n,t1) && binary_search(buf,buf+n,t2))
                    ++ans;
                t1.x = buf[j].x - (buf[i].y - buf[j].y);
                t1.y = buf[j].y + (buf[i].x - buf[j].x);
                t2.x = buf[i].x - (buf[i].y - buf[j].y);
                t2.y = buf[i].y + (buf[i].x - buf[j].x);
                if(binary_search(buf,buf+n,t1) && binary_search(buf,buf+n,t2))
                    ++ans;
            }
        }
        printf("%d
", ans / 4);
    }
    return 0;
}