poj2002（Squares）

题目地址：Squares

题目大意;

     给你N个坐标顶点，通过连接各个顶点，构成正方形，问最多有多少个正方形。通过不同的顺序构成的正方形视为同一正方形。

解题思路：

    O（n^4）超时。这时想通过两个坐标顶点是否可以查找是否构成正方形。

通过三角形全等得：

已知： (x1,y1)  (x2,y2)

则：  

    x3=x1+(y1-y2)   y3= y1-(x1-x2)

    x4=x2+(y1-y2)   y4= y2-(x1-x2)

或

    x3=x1-(y1-y2)   y3= y1+(x1-x2)

    x4=x2-(y1-y2)   y4= y2+(x1-x2)

通过两个坐标可以确定另外两个坐标。以为属于枚举了四个顶点，所以最后结果应该除以4.

通过hash 将各个顶点存起来。  然后通过x1，x2，y1，y2计算出的x3，y3，x4，y4分别去判断已经存起来的顶点是否存在，如存在即可以构成。

代码1：

Memory: 540K

Time: 1329MS

链表模拟拉链。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;

struct no
{
    int x;
    int y;
} node[1001];
struct map
{
    int x;
    int y;
    struct map *next;
} *m[2010];
int hash1(int x,int y)
{
    int key=(x*x+y*y)%2000;
    if (!m[key])
    {
        map *temp=(map *)malloc(sizeof(map));
        temp->x=x;
        temp->y=y;
        temp->next=NULL;
        m[key]=temp;
    }
    else
    {
        map *temp=m[key];
        while(temp)
            temp=temp->next;
        temp=(map *)malloc(sizeof(map));
        temp->x=x;
        temp->y=y;
        temp->next=NULL;
    }
}
int find(int x,int y)
{
    int key=(x*x+y*y)%2000;
    if (m[key])
    {
        map *temp=m[key];
        while(temp)
        {
            if (temp->x==x&&temp->y==y)
                return 1;
            temp=temp->next;
        }
    }
    return 0;
}
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        int i,j,x3,y3,x4,y4,cas=0;
        memset(m,0,sizeof(m));
        for(i=0; i<n; i++)
        {
            scanf("%d%d",&node[i].x,&node[i].y);
            hash1(node[i].x,node[i].y);
        }
        /*
           (x1,y1)  (x2,y2)
           x3=x1+(y1-y2)   y3= y1-(x1-x2)
           x4=x2+(y1-y2)   y4= y2-(x1-x2)
           x3=x1-(y1-y2)   y3= y1+(x1-x2)
           x4=x2-(y1-y2)   y4= y2+(x1-x2)*/
        for(i=0; i<n; i++)
            for(j=0; j<n; j++)
            {
                if (j==i)
                    continue;
                 x3=node[i].x+(node[j].y-node[i].y);
                 y3=node[i].y-(node[j].x-node[i].x);
                 x4=node[j].x+(node[j].y-node[i].y);
                 y4=node[j].y-(node[j].x-node[i].x);
                 if (find(x3,y3)&&find(x4,y4))
                     cas++;
                 x3=node[i].x-(node[j].y-node[i].y);
                 y3=node[i].y+(node[j].x-node[i].x);
                 x4=node[j].x-(node[j].y-node[i].y);
                 y4=node[j].y+(node[j].x-node[i].x);
                 if (find(x3,y3)&&find(x4,y4))
                     cas++;
            }
        printf("%d
",cas/4);
    }
    return 0;
}

代码2：

Memory: 180K

Time: 891MS

数组模拟拉链。

#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
//#include <map>
#include <set>
using namespace std;
/***************************************/
#define ll long long
#define int64 __int64
/***************************************/
const int INF = 0x7f7f7f7f;
const double eps = 1e-8;
const double PIE=acos(-1.0);
const int d1x[]= {0,-1,0,1};
const int d1y[]= {-1,0,1,0};
const int d2x[]= {0,-1,0,1};
const int d2y[]= {1,0,-1,0};
const int fx[]= {-1,-1,-1,0,0,1,1,1};
const int fy[]= {-1,0,1,-1,1,-1,0,1};
/*vector <int>map[N];map[a].push_back(b);int len=map[v].size();*/
/***************************************/
void openfile()
{
    freopen("data.in","rb",stdin);
    freopen("data.out","wb",stdout);
}
/**********************华丽丽的分割线,以上为模板部分*****************/
struct Node
{
    int x,y;
} node[1001];
const int M=1999;
int hash[2000],next[2000];
int hashcode(int x,int y)
{
    int p=0;
    p=(p<<6)+(x>>6)^(x<<6);
    p=(p<<6)+(y>>6)^(y<<6);
    p%=M;
    if (p<0)
        p+=M;
    return p;
}
int cmp(int x,int y)
{
    int p;
    int h=hashcode(x,y);
    for(p=hash[h]; p!=-1; p=next[p])
        if (node[p].x==x&&node[p].y==y)
            return 1;
    return 0;
}
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        int i,j;
        int x1,x2,x3,x4,y1,y2,y3,y4;
        memset(hash,-1,sizeof(hash));
        for(i=0; i<n; i++)
        {
            scanf("%d%d",&node[i].x,&node[i].y);
            int h=hashcode(node[i].x,node[i].y);
            next[i]=hash[h];
            hash[h]=i;
        }
        int cnt=0;
        for(i=0; i<n; i++)
        {
            for(j=i+1; j<n; j++)
            {
                x1=node[i].x;
                x2=node[j].x;
                y1=node[i].y;
                y2=node[j].y;
                x3=x1+(y1-y2);
                y3=y1-(x1-x2);
                x4=x2+(y1-y2);
                y4=y2-(x1-x2);
                if (cmp(x3,y3)&&cmp(x4,y4))
                    cnt++;
                x3=x1-(y1-y2);
                y3=y1+(x1-x2);
                x4=x2-(y1-y2);
                y4=y2+(x1-x2);
                if (cmp(x3,y3)&&cmp(x4,y4))
                    cnt++;
            }
        }
        printf("%d
",cnt/4);
     }
     return 0;
}