USACO Wormholes 【DFS】

深碍√TFBOYSˉ_ 2021-12-10 16:41 240阅读 0赞

## 描述 ##

农夫约翰爱好在周末进行高能物理实验的结果却适得其反，导致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 方向走进来，虽然他不记得贝茜的当前位置。请帮助农夫约翰计算不同的虫洞配对（情况），使贝茜可能被困在一个无限循环中，如果她从不幸的位置开始。

## \[[编辑][Link 1]\]格式 ##

**PROGRAM NAME:** wormhole

**INPUT FORMAT:**

(file wormhole.in)

第1行：N，虫洞的数目

第2到N+1行：每一行都包含两个空格分隔的整数，描述一个以(x,y)为坐标的单一的虫洞。每个坐标是在范围 0..1000000000。

**OUTPUT FORMAT:**

(file wormhole.out)

第1行：会使贝茜从某个起始点出发沿+x方向移动卡在循环中的不同的配对数。

## \[[编辑][Link 2]\]SAMPLE INPUT ##

4
    0 0
    1 0
    1 1
    0 1

## \[[编辑][Link 3]\]SAMPLE OUTPUT ##

## \[[编辑][Link 4]\]HINTS ##

### \[[编辑][Link 5]\]输入详细信息 ###

有4个虫洞，在一个正方形角上。

### \[[编辑][Link 6]\]输出详细信息 ###

如果我们将虫洞编号为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-7      ;
    const int M = 200000         ;
    const ll P = 10000000097ll   ;
    const int INF = 0x3f3f3f3f   ;
    const int MAX_N = 20         ;
    
    int N, X[MAX_N + 1], Y[MAX_N + 1];
    int partner[MAX_N + 1];
    int next_on_right[MAX_N + 1];
    
    bool cycle_exists(void){
        for (int start = 1; start <= N; ++start){
            int pos = start;
            for (int count = 0; count < N; ++count){
                pos = next_on_right[partner[pos]];
            }
            if (pos != 0) return true;  // does there exist a cylce starting from start
        }
        return false;
    }
    
    int solve(){                        // count all solutions
        int i, ans = 0;
        for (i = 1; i <= N; ++i)
            if (partner[i] == 0) break;  // find first unpaired wormhole
        if (i > N) {                     // everyone paired?
            if (cycle_exists()) return 1;
            else return 0;
        }
        for (int j = i + 1; j <= N; ++j) // try pairing i with all possible other wormholes j
            if (partner[j] == 0){
                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] = 0;
            }
        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, 0, sizeof(next_on_right));
        memset(partner, 0, sizeof(partner));
        fin >> N;
        for (i = 1; i <= N; ++i){
            fin >> X[i] >> Y[i];
        }
        for (i = 1; i <= N; ++i){ // set next_on_right[i]...
            for (j = 1; j <= N; ++j){
                if (X[j] > X[i] && Y[i] == Y[j]){ // j right of i...
                    if (next_on_right[i] == 0 || 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 0;
    }

转载于:https://www.cnblogs.com/wushuaiyi/p/4253840.html

[Link 1]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=2
[Link 2]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=3
[Link 3]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=4
[Link 4]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=5
[Link 5]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=6
[Link 6]: http://www.nocow.cn/index.php?title=Translate:USACO/wormhole&action=edit&section=7