POJ 2002, Squares

Time Limit: 3500MS  Memory Limit: 65536K
Total Submissions: 6320  Accepted: 2024

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
Rocky Mountain 2004

---

//  POJ2002.cpp : Defines the entry point for the console application.
//

#include  < iostream >
#include  < algorithm >
using   namespace  std;

struct  Point
{
     int  x;
     int  y;
};

struct  Node
{
    Node():next( 0 ){}
     int  x;
     int  y;
    Node *  next;
};

bool  findPoint(Node hash[],  int  x,  int  y,  int  SIZE)
{
     int  key  =  (x  *  x  +  y  *  y)  %  SIZE;
    Node *  pt  =   & hash[key];
     while  (pt -> next  !=  NULL)
    {
        pt  =  pt -> next;
         if  (pt -> x  ==  x  &&  pt -> y  ==  y) return   true ;
    }
     return   false ;
};

int  main( int  argc,  char *  argv[])
{
     const   int  SIZE  =   33119 ;
    Point pts[ 1000 ];
    Node hash[SIZE];

     int  n;
     while (cin  >>  n  &&  n  !=   0 )
    {
        memset(hash, 0 , sizeof (hash));
         for  ( int  i  =   0 ; i  <  n;  ++ i)
        {
            Node *  pn  =   new  Node;
            scanf( " %d %d " ,  & pts[i].x,  & pts[i].y);
            pn -> x  =  pts[i].x;
            pn -> y  =  pts[i].y;
             int  key  =  (pn -> x  *  pn -> x  +  pn -> y  *  pn -> y)  %  SIZE;
            Node *  pt  =   & hash[key];
             while  (pt -> next  !=  NULL)pt  =  pt -> next;
            pt -> next  =  pn;
        }

         int  cnt  =   0 ;
         for ( int  i  =   0 ; i  <  n;  ++ i)
             for  ( int  j  =  i  +   1 ; j  <  n;  ++ j)
            {
                 int  x  =  pts[i].x  -  pts[j].x;
                 int  y  =  pts[i].y  -  pts[j].y;

                 int  x1  =  pts[i].x  +  y;
                 int  y1  =  pts[i].y  -  x;
                 int  x2  =  pts[j].x  +  y;
                 int  y2  =  pts[j].y  -  x;

                 if  (findPoint(hash,x1,y1,SIZE)  &&  findPoint(hash,x2,y2,SIZE))  ++ cnt;

                x1  =  pts[i].x  -  y;
                y1  =  pts[i].y  +  x;
                x2  =  pts[j].x  -  y;
                y2  =  pts[j].y  +  x;

                 if  (findPoint(hash,x1,y1,SIZE)  &&  findPoint(hash,x2,y2,SIZE))  ++ cnt;
            };

        cout  <<  (cnt  >>   2 )  <<  endl;
    }
     return   0 ;
}

转载于:https://www.cnblogs.com/asuran/archive/2009/10/09/1579539.html