planar

题目描述

给出一个无向图（保证存在哈密顿回路），问能否把它画在一个平面上且任意两条无重合顶点的边不相交（称为平面图）。
最大数据：T=100 N=500 M=10000

样例

2 6
9
1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6
1 4 2 5 3 6
5 5
1 2
2 3
3 4
4 5
5 1
1 2 3 4 5

输出

NO
YES

解题

思路

由于最近学2sat学得疯狂，以致于迅速想到了POJ3207这道题。。。
尽管官方题解并不是这样做的。。。
我们可以这样想，首先把这个环画上去，对于每一条其他边，既可以从环外边连，也可以从环里边连，则对于两个都从环外边（或里边）连会相交的边，有：
a xor b=1。（a、b取0表示里边连，取1表示外边连（当然可以反过来定义））
然而，用普通的2sat显然会T，怎么办？

---

所以我们必须研究构出图的性质，显然，这个跟一般意义上的2sat是不一样的：每条边都是无向边。也即是说，只要连了边，都会成为一个联通分量里的点。
于是某大佬想到用并查集。
对于每两条会相交的边i、j，让i与j+m归并，j与i+m归并。最后判断i与i+m是否是同一个父亲即可。
但是，问题来了，判断两条边相交，复杂度：$O(M^2)$
炸了!

---

无奈，只好翻官方题解，官方题解是用二分图判断（其实本质上思想是一样的），但是用了一个特别神奇的东西：当M>3N-6时，必然无解。
于是，判断两个边相交的复杂度接近于$O（N^2）$了。。。
问题来了，这玩意怎么证明？
又是欧拉
由欧拉公式之V-E+F=2,V个顶点,E条边,F个面
对于这个平面图,最优时，3F=2E （每个面由3条边组成,一边被2个面共享）
代入得 E=3V-6
于是，完工，上代码

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
int n,m;
struct node{
    int u,v;
}e[1000005];
int hash[100005];
int fa[100005];
int find_father(int x){
    if(x==fa[x])
        return x;
    return fa[x]=find_father(fa[x]);
}
void merge(int x,int y){
    int f1=find_father(x),f2=find_father(y);
    if(f1==f2)
        return ;
    fa[f1]=f2;
}
int main()
{
    //freopen("planar.in","r",stdin);
    //freopen("planar.out","w",stdout);
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=2*m;i++)
            fa[i]=i;
        for(int i=1;i<=m;i++)
            scanf("%d%d",&e[i].u,&e[i].v);
        for(int i=1;i<=n;i++){
            int a;
            scanf("%d",&a);
            hash[a]=i;
        }
        if(m>3*n){
            printf("NO\n");
            continue ;
        }
        for(int i=1;i<=m;i++)
            for(int j=i+1;j<=m;j++){
                int u1=hash[e[i].u],v1=hash[e[i].v],u2=hash[e[j].u],v2=hash[e[j].v];
                if(u1>v1)
                    swap(u1,v1);
                if(u2>v2)
                    swap(u2,v2);
                if((u1<u2&&u2<v1&&v1<v2)||(u2<u1&&u1<v2&&v2<v1)){
                    merge(i,j+m);
                    merge(i+m,j);
                }
            }
        bool k=1; 
        for(int i=1;i<=m&&k;i++)
            if(find_father(i)==find_father(i+m)){
                printf("NO\n");
                k=0;
            }
        if(k)
            printf("YES\n");
    }
    fclose(stdin);
    fclose(stdout);
}

下面是某个老逗逼的二分图做法（下面的都是他敲的）

代码丑，不要嫌弃
首先把回路上的点张成一个环，那么如果两条边在里面相交，那么放在圈外面也会相交，因此把相交的点连边，黑白染色，推出矛盾就是NO了。
（黑色放里面，白色放外面）

---

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
int T,n,m,a[205],map[205][205],bs[20005][2],tot,cl[20005],key=0,b[205];
vector<int>w[20005];
bool cxj(int i,int j){
    if(bs[i][0]>bs[j][0])
        swap(i,j);
    if(bs[j][0]<bs[i][1]&&bs[j][1]>bs[i][1]&&bs[j][0]>bs[i][0])
        return 1;
    return 0;
}
void dfs(int u,int c){
    cl[u]=c;
    for(int i=0;i<int(w[u].size());i++)
    {
        if(!cl[w[u][i]])
        {
            dfs(w[u][i],c%2+1);
            if(key==1)
                return ;
        }
        else if(cl[w[u][i]]==cl[u])
        {
            key=1;
            return ;
        }
        if(key==1)
            return ;
    }
}
int main()
{
    freopen("planar.in","r",stdin);
    freopen("planar.out","w",stdout);
    scanf("%d",&T);
    while(T--)
    {
        key=0;
        fill(cl+1,cl+20000,0);
        for(int i=1;i<=20000;i++)
        {
            w[i].clear();
        }
        for(int i=1;i<=200;i++)
        {
            fill(map[i],map[i]+200,0);
        }
        scanf("%d %d",&n,&m);
        for(int i=1;i<=m;i++){
            int u,v;
            scanf("%d %d",&u,&v);
            if(u>v)
                swap(u,v);
            map[u][v]=1;
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            map[min(a[i],a[i-1])][max(a[i],a[i-1])]=0;
        }
        map[min(a[1],a[n])][max(a[1],a[n])]=0;
        for(int i=1;i<=n;i++)
        {
            b[a[i]]=i;
        }
        if(m>3*n)
        {
            printf("NO\n");
            continue;
        }
        tot=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=i;j<=n;j++)
            {
                if(map[i][j]==1)
                {
                    bs[++tot][0]=min(b[i],b[j]);
                    bs[tot][1]=max(b[j],b[i]);
                }
            }
        }
        for(int i=1;i<=tot;i++)
        {
            for(int j=1;j<i;j++)
            {
                if(cxj(i,j))
                {
                    w[i].push_back(j);
                    w[j].push_back(i);
                }
            }
        }
        for(int i=1;i<=tot;i++)
        {
            if(!cl[i])
            {
                dfs(i,1);
                if(key==1)
                    break;
            }
        }
        if(key==1)
            printf("NO\n");
        else
            printf("YES\n");
    }
    fclose(stdin);
    fclose(stdout);
}

---