码迷,mamicode.com
首页 > 其他好文 > 详细

Poj2002 Squares

时间:2014-08-14 13:27:28      阅读:357      评论:0      收藏:0      [点我收藏+]

标签:style   blog   color   使用   io   strong   for   ar   

题意描述:有一堆平面散点集,任取四个点,求能组成正方形的不同组合方式有多少。相同的四个点,不同顺序构成的正方形视为同一正方形。

思路变迁

1、最简单的方法,直接暴力搜索,即依次取四个顶点,根据其坐标判断是否能组成正方形。组成正方形的条件是四个顶点可组成的六条边里面,有四条相等,剩下两条相等。当然由于其时间复杂度为O(n^4),所以提交结果为TLE

2、考虑降低时间复杂度。如任取三个顶点,根据组成正方形的条件计算得到第四个顶点,判断其是否在点的集合内,其复杂度为O(n^3)。或者任取两个顶点,根据组成正方形的条件计算出另外两个顶点,再判断其是否在点的集合内,其复杂度为O(n^2)。

3、不论是任取两个顶点还是任取三个顶点,其关键一步都是判断计算得到的新的点,是否在点的集合内,基本方法有对点排序再二分查找,或者是使用hash表。我的设计是考虑点所处象限的二维hash表。根据这道题的提交结果来看,所用时间上,堆排序优于快排

4、对于任选两个顶点时,可能存在三种不同的正方形。但是在对所有顶点排序后,如若按序来去顶点,则可发现我们只需始终计算一个方向的即可,且计算结果中同一个正方形重复了两次,所以最终结果除以二。如若不排序直接任取两个的顶点的话,始终按一个方向计算,可以发现每个正方形的四条边,每一条边都会贡献一次得到的正方形的个数,所以最终结果需要除以四

5、在使用hash表后时间复杂度达到最优,即O(nlgn) + hash表平均冲突*n(n-1)/2,所以本问题的进一步优化,取决于怎么更大程度的降低hash表的冲突?考虑位运算,来存储所有的点,但需要空间太大,因为共有40000*40000个点

暴力搜索代码

 1 #include<stdio.h>
 2 #define SIZE 1005
 3 typedef struct POINT {
 4     int x;
 5     int y;
 6 } point;
 7 int isSquare(int a, int b, int c, int d);
 8 point p[SIZE];
 9 int main() {
10     int n, result;
11     int i, j, k, x;
12     scanf("%d", &n);
13     while(n != 0) {
14         result = 0;
15         for(i=1; i<=n; i++)
16             scanf("%d %d", &p[i].x, &p[i].y);
17         for(i=1; i<=n; i++) {
18             for(j=i+1; j<=n; j++) {
19                 for(k=j+1; k<=n; k++) {
20                     for(x=k+1; x<=n; x++) {
21                         if(isSquare(i, j, k, x))
22                             result++;
23                     }
24                 }
25             }
26         }
27         printf("%d\n", result);
28         scanf("%d", &n);
29     }
30 }
31 
32 int isSquare(int a, int b, int c, int d) {
33     int s[6];
34     int num1 = 1, num2 = 1;
35     int side1 = -1, side2 = -1;
36     int i;
37     s[0] = (p[a].x - p[b].x)*(p[a].x - p[b].x) + (p[a].y - p[b].y)*(p[a].y - p[b].y);
38     s[1] = (p[a].x - p[c].x)*(p[a].x - p[c].x) + (p[a].y - p[c].y)*(p[a].y - p[c].y);
39     s[2] = (p[a].x - p[d].x)*(p[a].x - p[d].x) + (p[a].y - p[d].y)*(p[a].y - p[d].y);
40     s[3] = (p[b].x - p[c].x)*(p[b].x - p[c].x) + (p[b].y - p[c].y)*(p[b].y - p[c].y);
41     s[4] = (p[b].x - p[d].x)*(p[b].x - p[d].x) + (p[b].y - p[d].y)*(p[b].y - p[d].y);
42     s[5] = (p[c].x - p[d].x)*(p[c].x - p[d].x) + (p[c].y - p[d].y)*(p[c].y - p[d].y);
43     for(i=0; i<=5; i++) {
44         if(i == 0) {
45             side1 = s[i];
46         }
47         else if(s[i] != side1) {
48             if(side2 == -1)
49                 side2 = s[i];
50             else if(s[i] == side2)
51                 num2++;
52             else
53                 break;
54         }
55         else if(s[i] == side1)
56             num1++;
57     }
58     if((num1==2 && num2==4) || (num1==4 && num2 == 2))
59         return 1;
60     else
61         return 0;
62 }

使用堆排序+二分查找代码

 1 #include<stdio.h>
 2 #define SIZE 1005
 3 typedef struct POiNT {
 4     int x;
 5     int y;
 6 } point;
 7 int cmp(point pa, point pb);
 8 void heapSort(int n);
 9 int binarySearch(int low, int high, point key);
10 void shiftDown(int i, int n);
11 void swap(int i, int j);
12 point p[SIZE];
13 int main() {
14     int n, result;
15     int i, j, k, x;
16     point pa, pb;
17     scanf("%d", &n);
18     while(n != 0) {
19         result = 0;
20         for(i=1; i<=n; i++)
21             scanf("%d %d", &p[i].x, &p[i].y);
22         heapSort(n);
23         for(i=1; i<=n; i++)
24             printf("%d %d\n", p[i].x, p[i].y);
25 
26         for(i=1; i<=n; i++) {
27             for(j=i+1; j<=n; j++) {
28                 pa.x = p[i].x - (p[j].y - p[i].y);
29                 pa.y = p[i].y + (p[j].x - p[i].x);
30                 pb.x = pa.x + (p[j].x - p[i].x);
31                 pb.y = pa.y + (p[j].y - p[i].y);
32                 if(binarySearch(1, n, pa) && binarySearch(1, n, pb))
33                     result++;
34             }
35         }
36         printf("%d\n", result/2);
37         scanf("%d", &n);
38     }
39 }
40 int binarySearch(int low, int high, point key) {
41     int mid = (low + high)/2;
42     if(low > high)
43         return 0;
44     if(cmp(p[mid], key) == 0)
45         return 1;
46     else if(cmp(p[mid], key) == 1)
47         return binarySearch(low, mid-1, key);
48     else
49         return binarySearch(mid+1, high, key);
50 }
51 void heapSort(int n) {
52     int i = n/2;
53     for(; i>0; --i)
54         shiftDown(i, n);
55     for(i=n; i>1;) {
56         swap(1, i);
57         shiftDown(1, --i);
58     }
59 }
60 void shiftDown(int i, int n) {
61     int j = 2*i;
62     for(; j<=n; j=2*i) {
63         if(j < n && cmp(p[j], p[j+1]) == -1)
64             j = j + 1;
65         if(cmp(p[i], p[j]) == -1) {
66             swap(i, j);
67             i = j;
68         } else
69             break;
70     }
71 }
72 void swap(int i, int j) {
73     point temp = p[i];
74     p[i] = p[j];
75     p[j] = temp;
76 }
77 int cmp(point pa, point pb) {
78     if(pa.x > pb.x)
79         return 1;
80     else if(pa.x == pb.x && pa.y > pb.y)
81         return 1;
82     else if(pa.x == pb.x && pa.y == pb.y)
83         return 0;
84     else
85         return -1;
86 }

考虑象限的hash代码

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<string.h>
 4 #define SIZE 1013
 5 typedef struct POiNT {
 6     int x;
 7     int y;
 8 } point;
 9 struct hashNode {
10     point poi;
11     struct hashNode *next;
12 };
13 int cmp(const void *a, const void *b );
14 void add(point key);
15 int find(point);
16 point p[SIZE];
17 struct hashNode hashTable[5][SIZE];
18 int main() {
19     int n, result;
20     int i, j, k, x;
21     point pa, pb;
22     scanf("%d", &n);
23     while(n != 0) {
24         result = 0;
25         memset(hashTable, 0, sizeof(hashTable));
26         for(i=1; i<=n; i++) {
27             scanf("%d %d", &p[i].x, &p[i].y);
28             add(p[i]);
29         }
30         qsort(p+1, n, sizeof(p[0]), cmp);
31         for(i=1; i<=n; i++) {
32             for(j=i+1; j<=n; j++) {
33                 pa.x = p[i].x - (p[j].y - p[i].y);
34                 pa.y = p[i].y + (p[j].x - p[i].x);
35                 pb.x = pa.x + (p[j].x - p[i].x);
36                 pb.y = pa.y + (p[j].y - p[i].y);
37                 if(find(pa) && find(pb))
38                     result++;
39             }
40         }
41         printf("%d\n", result/2);
42         scanf("%d", &n);
43     }
44 }
45 void add(point key) {
46     int t, num;
47     struct hashNode *newNode;
48     if(key.x >= 0 && key.y >= 0)
49         t = 1;
50     else if(key.x >= 0 && key.y < 0)
51         t = 2;
52     else if(key.x < 0 && key.y < 0)
53         t = 3;
54     else
55         t = 4;
56     num = (key.x*key.x + key.y*key.y)%SIZE;
57     newNode = (struct hashNode*)malloc(sizeof(struct hashNode));
58     newNode->poi = key;
59     newNode->next = hashTable[t][num].next;
60     hashTable[t][num].next = newNode;
61 }
62 int find(point key) {
63     int t, num;
64     struct hashNode *node;
65     if(key.x >= 0 && key.y >= 0)
66         t = 1;
67     else if(key.x >= 0 && key.y < 0)
68         t = 2;
69     else if(key.x < 0 && key.y < 0)
70         t = 3;
71     else
72         t = 4;
73     num = (key.x*key.x + key.y*key.y)%SIZE;
74     node = hashTable[t][num].next;
75     while(node) {
76         if(node->poi.x == key.x && node->poi.y == key.y)
77             return 1;
78         node = node->next;
79     }
80     return 0;
81 }
82 int cmp(const void *a, const void *b )
83 {
84    point c = *(point*)a;
85    point d = *(point*)b;
86 
87     if(c.x == d.x)
88         return c.y - d.y;
89     else
90         return c.x - d.x;
91 }

 

Poj2002 Squares,布布扣,bubuko.com

Poj2002 Squares

标签:style   blog   color   使用   io   strong   for   ar   

原文地址:http://www.cnblogs.com/zghaobac/p/3912034.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!