描述
农夫约翰爱好在周末进行高能物理实验的结果却适得其反，导致N个虫洞在农场上（2<=N<=12，n是偶数），每个在农场二维地图的一个不同点。
根据他的计算，约翰知道他的虫洞将形成 N/2 连接配对。例如，如果A和B的虫洞连接成一对，进入虫洞A的任何对象体将从虫洞B出去，朝着同一个方向，而且进入虫洞B的任何对象将同样从虫洞A出去，朝着相同的方向前进。这可能发生相当令人不快的后果。
例如，假设有两个成对的虫洞A(1，1) 和 B(3，1)，贝茜从(2，1)开始朝着 +x 方向（右）的位置移动。贝茜将进入虫洞 B（在(3,1)），从A出去（在(1,1)），然后再次进入B，困在一个无限循环中！
| . . . .
| A > B . 贝茜会穿过B，A，
+ . . . . 然后再次穿过B
农夫约翰知道他的农场里每个虫洞的确切位置。他知道贝茜总是向 +x 方向走进来，虽然他不记得贝茜的当前位置。请帮助农夫约翰计算不同的虫洞配对（情况），使贝茜可能被困在一个无限循环中，如果她从不幸的位置开始。
[编辑]格式
PROGRAM NAME: wormhole
INPUT FORMAT:
(file wormhole.in)
第1行：N，虫洞的数目
第2到N+1行：每一行都包含两个空格分隔的整数，描述一个以(x,y)为坐标的单一的虫洞。每个坐标是在范围 0..1000000000。
OUTPUT FORMAT:
(file wormhole.out)
第1行：会使贝茜从某个起始点出发沿+x方向移动卡在循环中的不同的配对数。
[编辑]SAMPLE INPUT
4
0 0
1 0
1 1
0 1
[编辑]SAMPLE OUTPUT
2
[编辑]HINTS
[编辑]输入详细信息
有4个虫洞，在一个正方形角上。
[编辑]输出详细信息
如果我们将虫洞编号为1到4，然后通过匹配 1 与 2 和 3 与 4，贝茜会被卡住，如果她从(0，0)到(1,0)之间的任意位置开始或(0，1)和(1,1)之间。
| . . . .
4 3 . . . 贝茜会穿过B，A，
1-2-.-.-. 然后再次穿过B
相似的，在相同的起始点，贝茜也会陷入循环，如果配对是 1-3 和 2-4。
仅有1-4和2-3的配对允许贝西从任何二维平面上的点向+x方向走不出现循环。
不会做= =官方的代码：
/*
ID: wushuai2
PROG: wormhole
LANG: C++
*/
//#pragma comment(linker, "/STACK:16777216") //for c++ Compiler
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <cstring>
#include <cmath>
#include <stack>
#include <string>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <vector>
#include <algorithm>
#define Max(a,b) (((a) > (b)) ? (a) : (b))
#define Min(a,b) (((a) < (b)) ? (a) : (b))
#define Abs(x) (((x) > 0) ? (x) : (-(x)))
#define MOD 1000000007
#define pi acos(-1.0) using namespace std; typedef long long ll ;
typedef unsigned long long ull ;
typedef unsigned int uint ;
typedef unsigned char uchar ; template<class T> inline void checkmin(T &a,T b){if(a>b) a=b;}
template<class T> inline void checkmax(T &a,T b){if(a<b) a=b;} const double eps = 1e- ;
const int M = ;
const ll P = 10000000097ll ;
const int INF = 0x3f3f3f3f ;
const int MAX_N = ; int N, X[MAX_N + ], Y[MAX_N + ];
int partner[MAX_N + ];
int next_on_right[MAX_N + ]; bool cycle_exists(void){
for (int start = ; start <= N; ++start){
int pos = start;
for (int count = ; count < N; ++count){
pos = next_on_right[partner[pos]];
}
if (pos != ) return true; // does there exist a cylce starting from start
}
return false;
} int solve(){ // count all solutions
int i, ans = ;
for (i = ; i <= N; ++i)
if (partner[i] == ) break; // find first unpaired wormhole
if (i > N) { // everyone paired?
if (cycle_exists()) return ;
else return ;
}
for (int j = i + ; j <= N; ++j) // try pairing i with all possible other wormholes j
if (partner[j] == ){
partner[i] = j; // try pairing i & j, let recursion continue to
partner[j] = i; // generate the rest of the solution
ans += solve();
partner[i] = partner[j] = ;
}
return ans;
} int main() {
ofstream fout ("wormhole.out");
ifstream fin ("wormhole.in");
int i, j, k, t, m, s, c, w, q;
memset(next_on_right, , sizeof(next_on_right));
memset(partner, , sizeof(partner));
fin >> N;
for (i = ; i <= N; ++i){
fin >> X[i] >> Y[i];
}
for (i = ; i <= N; ++i){ // set next_on_right[i]...
for (j = ; j <= N; ++j){
if (X[j] > X[i] && Y[i] == Y[j]){ // j right of i...
if (next_on_right[i] == || X[j] - X[i] < X[next_on_right[i]] - X[i]){ //find next_on_right[i]
next_on_right[i] = j;
}
}
}
}
fout << solve() << endl;
//cout << solve() << endl; fin.close();
fout.close();
return ;
}