USACO 1.3 Wormholes

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):

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):

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.

Submission file Name: USACO Gateway | Comment or Question

(转自[USACO])

　　讲一下题目大意。Farmer John(USACO的标志人物啊)特别喜欢做实验，使得农场上出现了N（N <= 12）个虫洞，现在将这N个虫洞两两配对，配对了的虫洞从其中一个进入就会从对应的一个虫洞出来。Bessie在田园中总是向x轴的正方向前进。John想知道，有多少种虫洞的配对方案可以让Bessie在田园中某一个地方出发，会陷入死循环。

　　很明显的搜索（数据范围小），因为（1,2）(3,4)和(3,4)(1,2)是同一种匹配，所以每一次搜索的时候就找到编号最小的一个虫洞和其他的虫洞匹配。

　　接下来就是判断是否会陷入死循环。还算比较好想。首先给每个虫洞预处理出一个right，表示从它出来，往右走遇到的第一个虫洞的编号，如果不存在，就记个0吧。然后用个数组记录一下类似于Tarjan的时间戳的一个东西，每次循环访问的时候记一个编号（当然设成一样的），如果下一虫洞没有访问，那么就把编号设成当前的编号，否则判断它是否和现在的编号相等，如果相等，就说明会陷入死循环。

Code

 /*
 ID:
 PROG: wormhole
 LANG: C++11
 */
 /**
  * USACO
  * Accpeted
  * Time:0ms
  * Memory:4184k
  */
 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #define INF 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)
 template<typename T>
 inline void readInteger(T& u){
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-');
     if(x == '-'){
         x = getchar();
         aFlag = -;
     }
     for(u = x - ''; isdigit((x = getchar())); u = (u << ) + (u << ) + x - '');
     ungetc(x, stdin);
     u *= aFlag;
 }
 
 typedef class Point {
     public:
         int x;
         int y;
         int id;
         boolean operator < (Point another) const {
             if(this->y != another.y)    return this->y < another.y;
             return this->x < another.x;
         }
 }Point;
 
 int n;
 int* onright;
 Point* ps;
 
 inline void init(){
     readInteger(n);
     ps = new Point[(const int)(n + )];
     onright = new int[(const int)(n + )];
     for(int i = ; i <= n; i++){
         readInteger(ps[i].x);
         readInteger(ps[i].y);
         ps[i].id = i;
         onright[i] = ;
     }
 }
 
 int* matches;
 boolean* seced;
 int res;
 
 boolean check(){
     int vis[(const int)(n + )];
     memset(vis, , sizeof(vis));
     vis[] = -;
     for(int i = ; i <= n; i++){
         if(vis[i] != )    continue;
         int p = i;
         while(vis[p] == ){
             vis[p] = i;
             p = onright[p];
             if(seced[p])    p = matches[p];
         }
         if(vis[p] == i)    return true;
     }
     return false;
 }
 
 void search(int choosed){
     if(choosed +  > n){
         if(check())    res++;
         return;
     }
     int sta;
     for(int i = ; i <= n; i++)
         if(!seced[i]){
             sta = i;
             break;
         }
     seced[sta] = true;
     for(int i = sta + ; i <= n; i++){
         if(!seced[i]){
             matches[sta] = i;
             matches[i] = sta;
             seced[i] = true;
             search(choosed + );
             seced[i] = false;
         }
     }
     seced[sta] = false;
 }
 
 inline void solve(){
     matches = new int[(const int)(n + )];
     seced = new boolean[(const int)(n + )];
     memset(seced, false, sizeof(boolean) * (n + ));
     sort(ps + , ps + n + );
     for(int i = ; i < n; i++){
         if(ps[i + ].y == ps[i].y){
             onright[ps[i].id] = ps[i + ].id;
         }
     }
     search();
     printf("%d\n", res);
 }
 
 int main(){
     freopen("wormhole.in", "r", stdin);
     freopen("wormhole.out", "w", stdout);
     init();
     solve();
     return ;
 }