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;
}