UASCO Wormholes 解析 and C 语言实现

题目大意：

农场有N个洞（2<=N<=12,N为偶数），且组成N/2个连接对。每个洞的给出平面坐标（x,y）。

如果A和B相连，则进入A会从B出来，进入B会从A出来。有只会沿着x轴正方向前进的牛，很可能就会陷入一个循环中。例如，A（1,1），B（3,1），这头牛从（2,1）出发，首先会进入B，然后从A出来，因为牛只沿着x方向前进，牛又进入了B，就这样无限循环下去了。

给定N个洞的坐标，牛可以从任何点出发，求所有可能出现 牛陷入循环的可能情况数（及N个洞的配对情况）

 

 

分析：

这个题目有个关键点，就是牛的走向，及牛只能沿着x轴的正方向行走，要想形成无限循环，及每 当牛每次经过一个pair后，总能在其x正方向处存在下一个点。

 

所以题目的关键变为 寻找 平行的右邻接点 

 

N的数目较小，对所有的情况进行列举即可。

 

另外，无限循环的检测，发现一个 周期 即可，或者，走过的次数大于 各个周期最大行走次数 后，这个点还有平行的右邻接点。因为一共就N个点，周期最大行走次数 肯定不会大于N （是否 不会大于N/2 还有待思考 ）

/*
ID: abc18711
LANG: C
TASK: wormhole
*/
#include <stdio.h>
#include <string.h>

#define MAXN 12+1

int X[MAXN];
int Y[MAXN];

int pair[MAXN];
int right_hole[MAXN];

int N;


int exist_cycle()
{
	int start_hole;
	int flag;
	int i;

	for (start_hole=1; start_hole<=N; start_hole++)
	{
		for (i=1,flag=start_hole; i<=N; i++)
		{
			flag = right_hole[ pair[flag] ];
			if(flag == 0) break;
		}
		if (flag > 0) return 1;
	}

	return 0;
		
}

// the pair combination

int solutions()
{
	int i;
	int j;
	int total = 0;
	
	//find first unpaired hole
	for (i=1; i<=N; i++)
		if(pair[i] == 0) break;
	
	//no unpaired hole,test the cycle
	if (i > N){
		return exist_cycle();
	}
	

        //pairing i and j
	for (j=i+1; j<=N; j++)
		if (pair[j] == 0)
		{
			pair[i] = j;
			pair[j] = i;
			total += solutions();
			pair[i] = pair[j] = 0;
		}

	return total;
}


int main()
{
	int i;
	int j;
	
        FILE *fin = fopen("wormhole.in", "r");
	FILE *fout = fopen("wormhole.out", "w");
	

	// get the input 
	fscanf(fin, "%d", &N);
	
	for (i=1; i<=N; i++)
		fscanf(fin, "%d %d", &X[i], &Y[i]);

	memset(pair, 0, MAXN*sizeof(int));
	memset(right_hole, 0, MAXN*sizeof(int));

	// find the right hole
	for( i=1; i<=N; i++)
		for (j=1; j<=N; j++)
			if (Y[i] == Y[j] && X[j] > X[i])
				if (right_hole[i] == 0 || (X[j]-X[i]) < (X[ right_hole[i] ]-X[i]))
					right_hole[i] = j;

	fprintf(fout, "%d\n", solutions());
	
	return 0;
}

附录：

Wormholes

Farmer John's hobby of conducting high-energy physics experiments on weekends has backfired, causing N wormholes (2 <= N <= 12, N even) to materialize on his farm, each located at a distinct point

 on the 2D map of his farm (the x,y coordinates are both integers).

According to his calculations, Farmer John knows that his wormholes will form N/2 connected pairs. For example, if wormholes A and B are connected as a pair, then

 any object entering wormhole A will exit wormhole B moving in the same direction, and any object entering wormhole B will similarly exit from wormhole A moving in

 the same direction. This can have rather unpleasant consequences.

For example, suppose there are two paired wormholes A at (1,1) and B at (3,1), and that Bessie the cow starts from position (2,1) moving in the +x direction. Bessie will 

enter wormhole B [at (3,1)], exit from A [at (1,1)], then enter B again, and so on, getting trapped in an infinite cycle!

   | . . . .   | A > B .      Bessie will travel to B then   + . . . .      A then across to B again

Farmer John knows the exact location of each wormhole on his farm. He knows that Bessie the cow always walks in the +x direction, although he does not remember

 where Bessie is currently located.

Please help Farmer John count the number of distinct pairings of the wormholes such that Bessie could possibly get trapped in an infinite cycle if she starts from an 

unlucky position. FJ doesn't know which wormhole pairs with any other wormhole, so find all the possibilities.

PROGRAM NAME: wormhole

INPUT FORMAT:

Line 1:	The number of wormholes, N.
Lines 2..1+N:	Each line contains two space-separated integers describing the (x,y) coordinates of a single wormhole.  Each coordinate is in the range 0..1,000,000,000.

SAMPLE INPUT (file wormhole.in):

4

0 0

1 0

1 1

0 1

INPUT DETAILS:

There are 4 wormholes, forming the corners of a square.

OUTPUT FORMAT:

Line 1:

The number of distinct pairings of wormholes such that Bessie could conceivably get stuck in  a cycle walking from some starting point in the +x direction.

SAMPLE OUTPUT (file wormhole.out):

2

OUTPUT DETAILS:

If we number the wormholes 1..4 as we read them from the input, then if wormhole 1 pairs with wormhole 2 and wormhole 3 pairs with wormhole 4, 

Bessie can get stuck if she starts anywhere between (0,0) and (1,0) or between (0,1) and (1,1).

   | . . . .   4 3 . . .      Bessie will travel to B then   1-2-.-.-.      A then across to B again

Similarly, with the same starting points, Bessie can get stuck in a cycle if the pairings are 1-3 and 2-4 (if Bessie enters WH#3 and comes out at WH#1, she then walks to WH#2 which transports here to WH#4 which directs her towards WH#3 

again for a cycle).

Only the pairings 1-4 and 2-3 allow Bessie to walk in the +x direction from any point in the 2D plane with no danger of cycling.