USACO 1352. 虫洞

1352. 虫洞

这道题有些难度，我们需要去判断如果对虫洞进行配对可以得到成环的虫洞。
那么我们可以暴力搜索出来所有可以进行配对的虫洞，每当搜索出来一种配对方案，我们就判断在这个方案中是否存在环，如果存在环记入答案，否则不计入。
那么我们使用暴力做的话，时间复杂度是不会超时的：
枚举所有配对的方案：
11 * 9 * 7 * 5 * 3 * 2 * 1 = 10395 最多也就一万种方案，在使用Tarjan算法判断是否存在环。
判断是否存在环使用两个数组来进行判断，一个used数组，一个cur数组，我们遍历所有的点，used数组来表示已经遍历过的点，cur数组表示在当前栈中，也就是当前这条路径上已经遍历过的点，如果遍历到某个点，发现这个点在cur数组中已经存在，说明存在环，如果在cur数组中不存在，但是在used数组中存在，说明一定不存在环。

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 13;

struct Point{
    int x , y;
    // 先按纵坐标排序，在按横坐标排序，方便一行一行进行遍历
    bool operator< (const Point& p) const
    {
        if(y != p.y) return y < p.y;
        return x < p.x;
    }
}q[N];

int n ,res;
bool st[N]; // 记录爆搜是否被搜过
int to1[N] , to2[N]; // to1[i]=j: 记录从i点出来向右走到j点  to2[i]=j:记录从i点走到j点
bool used[N][2] , cur[N][2]; // 判断基树环,第二维0表示作为入点 1表示作为出点

bool dfs_c(int a , int b)
{
    if(cur[a][b])  return true; // 如果当前这个点已经在这条路径上，那么存在环
    if(used[a][b]) return false; // 如果当前这个点不在这条路径上，并且已经被使用过了，那么一定不存在环
    
    used[a][b] = cur[a][b] = true;
    bool res = false;
    if(!b) // a作为入点
    {
        if(dfs_c(to2[a] , 1)) res = true;
    }else
    {
        if(to1[a] != -1 &&  dfs_c(to1[a] , 0)) res = true;
    }
    cur[a][b] = false;
    return res;
}

bool check()
{
    memset(used , 0 , sizeof used);
    memset(cur , 0 , sizeof cur);
    
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            if(!used[i][j])
            {
                if(dfs_c(i,j)) return true;
            }
        }
    }
    return false;
}

// 遍历所有虫洞两两组合的情况
void dfs(int u)
{
    if(u == n/2) // 如果遍历完毕
    {
        if(check()) // 如果存在环
        {
            res ++;
            return ;
        }
    }
    for(int i = 0; i < n; i++)
    {
        if(!st[i])
        {
            for(int j = i+1; j < n; j++)
            {
                if(!st[j])
                {
                    st[i] = st[j] = true;
                    to2[i] = j , to2[j] = i;
                    dfs(u + 1);
                    st[i] = st[j] = false;
                    to2[i] = to2[j] = -1;
                }
            }
            // 只需要找到第一个没有配对的虫洞
            break;
        }
    }
}

int main()
{
    cin >> n;
    
    for(int i = 0; i < n; i++) cin >> q[i].x >> q[i].y;
    sort(q , q + n);
    
    memset(to1 , -1 , sizeof to1);
    memset(to2 , -1 , sizeof to2);
    // 逐行遍历虫洞
    for(int i = 1; i < n; i++)
    {
        // 如果当前虫洞和上一个虫洞在同一行，那么可以从i-1这个虫洞向右走到i这个虫洞
        if(q[i].y == q[i-1].y) to1[i-1] = i;
    }
    
    dfs(0); // 遍历所有虫洞两两组合的所有情况
    
    cout << res << endl;
    
    return 0;
}