poj2002

Squares

Time Limit: 3500MS		Memory Limit: 65536K
Total Submissions: 9185		Accepted: 3224

Description

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

Source

主要是利用直角关系跟距离关系。假设枚举的两个定点分别为（a1, a2）, (b1, b2),则对应的定点可能是( a1+(b2-a2), a2-(b1-a1)),( b1+(b2-a2), b2-(b1-a1))或者( a1-(b2-a2), a2+(b1-a1)),( b1-(b2-a2), b2+(b1-a1))

#include <iostream>
#include <cstring>
#include <cstdlib>

using namespace std;

const int prime=14997;

typedef struct
{
    int x;
    int y;
}Point;

typedef struct hashNode
{
    int p1, p2;
    struct hashNode* next;
}hashNode;

Point star[1000];
hashNode *hash[14997];


void insert(int i)
{
    hashNode *temp;
    int key;

    temp=(hashNode*)malloc(sizeof(hashNode));
    temp->p1=star[i].x;
    temp->p2=star[i].y;
    key=(star[i].x)*(star[i].x)+(star[i].y)*(star[i].y);
    key=key%prime;
    temp->next=hash[key];
    hash[key]=temp;
}

bool find(Point dp)
{
    hashNode *temp;
    int key;
    bool flag;

    flag=false;
    key=dp.x*dp.x+dp.y*dp.y;
    key=key%prime;
    temp=hash[key];
    while(temp)
    {
        if(temp->p1==dp.x && temp->p2==dp.y)
        {
            flag=true;
            break;
        }
        temp=temp->next;
    }
    return flag;


}

int main()
{
    int n;
    long cnt;
    Point dp1, dp2;
    int dx, dy;

    while(cin>>n && n)
    {
        cnt=0;
        memset(star,0,sizeof(star));
        memset(hash,0,sizeof(hash));
        for(int i=0; i<n; i++)
        {
            cin>>star[i].x>>star[i].y;
        }

        //make hash
        for(int i=0; i<n; i++)
        {
            insert(i);
        }

       for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                if(i==j)
                    continue;
                dx=star[i].x-star[j].x;
                dy=star[i].y-star[j].y;
                dp1.x=star[i].x+dy;
                dp1.y=star[i].y-dx;
                dp2.x=star[j].x+dy;
                dp2.y=star[j].y-dx;
                if(find(dp1)&&find(dp2))
                    cnt++;
            }
        }
        cout<<cnt/4<<endl;
    }

    return 0;
}