POJ 1971 Parallelogram Counting（hash）

Parallelogram Counting

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 6181		Accepted: 2119

Description

There are n distinct points in the plane, given by their integer coordinates. Find the number of parallelograms whose vertices lie on these points. In other words, find the number of 4-element subsets of these points that can be written as {A, B, C, D} such
that AB || CD, and BC || AD. No four points are in a straight line.
Input

The first line of the input contains a single integer t (1 <= t <= 10), the number of test cases. It is followed by the input data for each test case. 

The first line of each test case contains an integer n (1 <= n <= 1000). Each of the next n lines, contains 2 space-separated integers x and y (the coordinates of a point) with magnitude (absolute value) of no more than 1000000000. 

Output

Output should contain t lines. 

Line i contains an integer showing the number of the parallelograms as described above for test case i. 

Sample Input

2
6
0 0
2 0
4 0
1 1
3 1
5 1
7
-2 -1
8 9
5 7
1 1
4 8
2 0
9 8

Sample Output

5
6

Source

Tehran Sharif 2004 Preliminary

这道题的思路很简单，枚举所有线段的中点，每两个相同的中点可以确定一个平行四边形

对于判定相同的中点，一开始我用STL map试了一下，果断超时了

只能用hash了，hash函数的设计很重要，这里用的是折叠法，具体思路我上一篇博客有介绍

另外， hash冲突肯定会有的，这里用开放定址来解决

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <utility>
#include <map>
using namespace std;
typedef pair<int, int> PII;
const int MAXN = 1E3 + 5;
const int MOD = 1e6 + 39;

struct HashCheck {
int x, y;
} hashCheck[MOD];
int t, n, x[MAXN], y[MAXN];
int hashMap[MOD];

//折叠法随便hash一下
int Hash(int x, int y) {
int h = ((x << 2) + (x >> 4)) ^ (y << 9);
h %= MOD;
return h < 0 ? h + MOD : h;
}

void Insert(int x, int y) {
int hash = Hash(x, y);
bool yes = false;
if (hashMap[hash] == 0) {
++hashMap[hash];
hashCheck[hash].x = x;
hashCheck[hash].y = y;
}
else if (hashMap[hash] != 0 && hashCheck[hash].x == x && hashCheck[hash].y == y) {
++hashMap[hash];
}
else {
//开放定址法解决hash冲突
for (int i = hash + 1; ; ++i) {
if (i == MOD) i = 0;
if (hashMap[i] == 0) {
++hashMap[i];
hashCheck[i].x = x;
hashCheck[i].y = y;
break;
}
else if (hashMap[i] != 0 && hashCheck[i].x == x && hashCheck[i].y == y) {
++hashMap[i];
break;
}
}
}
}

int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}

memset(hashMap, 0, sizeof(hashMap));
memset(hashCheck, 0x3f, sizeof(hashCheck));
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int mx = x[i] + x[j];
int my = y[i] + y[j];
Insert(mx, my);
}
}

int ans = 0;
for (int i = 0; i < MOD; ++i) {
if (hashMap[i] >= 2) ans += hashMap[i] * (hashMap[i] - 1) / 2;
}
printf("%d\n", ans);
}
return 0;
}