[BZOJ 1997][Hnoi2010]Planar

1997: [Hnoi2010]Planar

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 2167  Solved: 804
[Submit][Status][Discuss]

Description

Input

Output

Sample Input

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

Sample Output

NO
YES

HINT

 

Source

Day1

题解

思路非常清奇...

首先图里存在哈密顿回路而且输入中已经给出, 那么如果要判断这个图是否是平面图, 我们首先一定会把这个哈密顿回路画在上面, 而且这部分没有优化余地.

然后剩下的不在环上的边则有两种选择: 从环里穿过去或者从环外绕过去. 根据边所连接的两个节点在哈密顿回路中的顺序确定如果边同时在环内是否会相交, 如果会相交的话这两条边必须分居哈密顿环两侧. 处理出所有之后判断可行性就好了

所以这个充满 $NPC$ 问题的题面实际上是个 $2-SAT$ ...QAQ

然后就是 $2-SAT$ 要加反向边(NOI 2017的惨痛教训)

参考代码

GitHub

#include <stack>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

const int MAXEX=1e6+10;
const int MAXE=1e4+10;
const int MAXV=2e3+10;

struct Edge{
    int from;
    int to;
    Edge* next;
};
Edge E[MAXE];
Edge Ex[MAXEX];
Edge* head[MAXV];
Edge* top=E;

int v;
int e;
int clk;
int scc;
int dfn[MAXV];
int low[MAXV];
int pos[MAXV];
int cycle[MAXV];
int belong[MAXV];

bool inStack[MAXV];

std::stack<int> s;

void Tarjan(int);
void Initialize();
void Insert(int,int);

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        Initialize();
        if(e>3*v-6){
            puts("NO");
            continue;
        }
        int cnt=0;
        for(int i=0;i<e;i++){
            E[i].from=pos[E[i].from];
            E[i].to=pos[E[i].to];
            if(E[i].from>E[i].to)
                std::swap(E[i].from,E[i].to);
            if(E[i].to-E[i].from==1||E[i].from==1&&E[i].to==v)
                continue;
            else
                E[cnt++]=E[i];
        }
        for(int i=0;i<cnt;i++){
            for(int j=i+1;j<cnt;j++){
                if((E[i].from<E[j].from&&E[i].to<E[j].to&&E[i].to>E[j].from)||(E[i].from>E[j].from&&E[i].to>E[j].to&&E[i].from<E[j].to)){
                    Insert(2*i+1,2*j);
                    Insert(2*i,2*j+1);
                    Insert(2*j+1,2*i);
                    Insert(2*j,2*i+1);
                }
            }
        }
        for(int i=0;i<2*cnt;i++){
            if(dfn[i]==0)
                Tarjan(i);
        }
        bool ans=true;
        for(int i=0;i<cnt;i++){
            if(belong[2*i]==belong[2*i+1]){
                ans=false;
                break;
            }
        }
        if(ans)
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

inline void Insert(int from,int to){
    top->from=from;
    top->to=to;
    top->next=head[from];
    head[from]=top++;
}

void Tarjan(int root){
    dfn[root]=low[root]=++clk;
    inStack[root]=true;
    s.push(root);
    for(Edge* i=head[root];i!=NULL;i=i->next){
        if(dfn[i->to]==0){
            Tarjan(i->to);
            low[root]=std::min(low[root],low[i->to]);
        }
        else if(inStack[i->to])
            low[root]=std::min(low[root],dfn[i->to]);
    }
    if(low[root]==dfn[root]){
        scc++;
        int top;
        do{
            top=s.top();
            belong[top]=scc;
            inStack[top]=false;
            s.pop();
        }while(top!=root);
    }
}

inline void Initialize(){
    memset(head,0,sizeof(head));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    clk=scc=0;
    top=Ex;
    scanf("%d%d",&v,&e);
    for(int i=0;i<e;i++){
        scanf("%d%d",&E[i].from,&E[i].to);
    }
    for(int i=1;i<=v;i++){
        scanf("%d",cycle+i);
        pos[cycle[i]]=i;
    }
}