P1444 [USACO1.3]虫洞wormhole

luogu P1444 [USACO1.3]虫洞wormhole

首先感谢ghj的讲解

题目描述

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

输入输出格式

输入格式：

第1行：N(N<=12)，虫洞的数目

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

输出格式：

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

输入输出样例

输入样例#1：

4
0 0
1 0
1 1
0 1

输出样例#1：

2

说明

若是咱们将虫洞编号为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，贝茜也会陷入循环。（若是贝西从3进去，1出来，她会走向2，而后被传送到4，最后又回到3）

仅有1-4和2-3的配对容许贝茜从任何二维平面上的点向+x方向走不出现循环。

首先个人思路是这样的(暴力连接两个点)：

for(int i=1;i<=n;++i){
    for(int j=i+1;j<=n;++j){
        if(!lk[i]&&!lk[j]){
            lk[i]=j,lk[j]=i;
            dfs(dep+1);
            lk[i]=lk[j]=0;
        }
    }
}

用两重循环去枚举

但ghj说这样太慢，容易超时

由于对于能够连接的点（lk[i]==0）咱们只去枚举第一个点和后面那些点连接

而不用两重循环去枚举（这样会有重复状态）

其实就是一个小优化：

for(int i=1;i<=n;++i){
    if(!lk[i]){
        for(int j=i+1;j<=n;++j){
            if(!lk[j]){
                lk[i]=j,lk[j]=i;
                dfs(dep+1);
                lk[i]=lk[j]=0;
            }
        }
        break;//划重点
    }
}

而后就是判环

ghj大佬说环有两种状况：

咱们先按y为第一关键字，x为第二关键字排序，则x如有右边能够到达的点

则那个点的编号确定为x+1

这样就造成了一个环

可是还有另一种状况：

这样就不是一个环

因此在判环的时候要判断一下

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define dou 0
const int maxn=15;
int n,m;
struct p{
    int x,y;
    friend bool operator < (const p &a,const p &b){return a.y==b.y? a.x<b.x:a.y<b.y;}
}a[maxn];
int read(){
    int s=0,f=1;char ch;
    while(!isdigit(ch=getchar()))(ch=='-')&&(f=-1);
    for(s=ch-'0';isdigit(ch=getchar());s=s*10+ch-'0');
    return s*f;
}
int vis[maxn];
int lk[maxn];
int ans=0;
bool ok(int x){
    int y=lk[x];
    // cout<<"x:"<<x<<"y:"<<y<<endl;
    while(1){
        if(a[y+1].y!=a[y].y)return dou;
        if(y+1==x)return 1;
        y=lk[y+1];
    }
}
void dfs(int dep){
    if(dep==n/2){
        // for(int i=1;i<=n;++i)cout<<lk[i]<<(i==n? '\n':' ');
        for(int i=1;i<=n;++i){if(ok(i)){ans++;break;}}
        return;
    }
    for(int i=1;i<=n;++i){
        if(!lk[i]){
            for(int j=i+1;j<=n;++j){
                if(!lk[j]){
                    lk[i]=j,lk[j]=i;
                    dfs(dep+1);
                    lk[i]=lk[j]=0;
                }
            }
            break;
        }
    }
}
int main(){
    n=read();
    for(int i=1;i<=n;++i){
        a[i]=p{read(),read()};
    }
    sort(a+1,a+1+n);
    dfs(0);
    cout<<ans<<endl;
    return 0;
}