BestCoder冠军赛 - 1009 Exploration 【Tarjan+并查集缩点】

【题意】

给一个图，这个图中既有有向边，又有无向边，每条边只能走一次，问图中是否存在环。

最多10^6个点，10^6个无向边，10^6个有向边

 

【题解】

因为既有有向边又有无向边，所以不能单纯的用tarjan判环，阻碍咱使用tarjan的主要还是无向边，显然不可以把无向边拆成两个有向边来搞，因为这条边只能走一次，拆成两条边可能来回分别走一次，就不满足题意了。

咱可以先处理无向边，无向边可能会把图连成一个个的连通块，用并查集，把这些连通块缩成一个点，注意，如果当发现某个无向边的两个端点在同一个并查集中，说明已经找到环了。

接下来就是处理有向边，直接用tarjan判环即可，还是要注意处理加入有向边的时候如果两个端点在同一个并查集中，说明已经找到环了，但是要注意你并不能立即输出并退出，因为这个是多CASE，所以需要读完整个数据才能退出。

 

============

写挂了两发，最后发现tarjan函数开始部分非常傻逼的把栈清空了。。。

 

 

#pragma comment(linker, "/STACK:102400000,102400000")

#include<cstdio>

#include<cstring>

#include<cmath>

#include<iostream>

#include<algorithm>

#include<set>

#include<map>

#include<stack>

#include<vector>

#include<queue>

#include<string>

#include<sstream>

#define eps 1e-9

#define ALL(x) x.begin(),x.end()

#define INS(x) inserter(x,x.begin())

#define FOR(i,j,k) for(int i=j;i<=k;i++)

#define MAXN 2000005

#define MAXM 4000005

#define INF 0x3fffffff

#define PB push_back

#define MP make_pair

#define X first

#define Y second

#define lc (k<<1)

#define rc ((k<<1)1)

using namespace std;

typedef long long LL;

int i,j,k,n,m,x,y,T,ans,big,cas,num,len;

bool flag;

int fa[MAXN]; 

int find(int x)

{

    if (x==fa[x]) return fa[x];

    return fa[x]=find(fa[x]);

}



int edge,head[MAXN];

struct edgenode

{

    int to,next;

} G[MAXM];



void add_edge(int x,int y)

{

    G[edge].to=y;

    G[edge].next=head[x];

    head[x]=edge++;

}





int K,indexs,nn,mm;

int dfn[MAXN],low[MAXN],instack[MAXN],belong[MAXN];

stack <int> tar;

 

bool tarjan(int k)

{

    int p,j;

    tar.push(k);

    instack[k]=1;

    dfn[k]=low[k]=++indexs;

    for(int j=head[k];j!=-1;j=G[j].next)

    {

        p=G[j].to;

        if (instack[p])

        {

            low[k]=min(low[k],dfn[p]);

        }

        else

        if(dfn[p]==-1)

        {

            if (tarjan(p)) return true;

            low[k]=min(low[k],low[p]);

        }

    }



    if(low[k]==dfn[k])

    {

        nn++;

        int sz=0;

        do

        {

            j=tar.top();

            tar.pop();

            instack[j]=0;

            belong[j]=nn;

            sz++;

        }while(j!=k);

        

        if (sz>1) return true;

    }

    return false;

}



bool build_map()

{

    memset(dfn,-1,sizeof(dfn));

    memset(low,-1,sizeof(low));

    memset(instack,0,sizeof(instack));

    indexs=0;nn=0;

    while (!tar.empty()) tar.pop();

    for (i=0;i<=n;i++) belong[i]=i;

    for (i=1;i<=n;i++)

    {

        if (fa[i]==i && dfn[i]==-1)

            if (tarjan(i)) return true;

    }

    

    return false;

}







bool RUN()

{

    memset(head,-1,sizeof(head));

    edge=0;

    int m1,m2;

    scanf("%d%d%d",&n,&m1,&m2);

    for (i=0;i<=n;i++) fa[i]=i;

    flag=false;

    for (i=1;i<=m1;i++)

    {

        scanf("%d%d",&x,&y);

        int fx=find(x);

        int fy=find(y);

        if (fx==fy) flag=true;

        else fa[fx]=fy;

    }

    

    for (i=1;i<=m2;i++)

    {

        scanf("%d%d",&x,&y);

        x=find(x);

        y=find(y);

        if (x==y) flag=true;

        add_edge(x,y);

    }

    if (flag) return true;

    return build_map();

}



int main()

{

    scanf("%d",&T);

    while (T--)

    {

        if (RUN()) printf("YES\n"); else printf("NO\n");

    }

    return 0;

}