BestCoder冠军赛

【题意】

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

最多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
"); else printf("NO
");
    }
    return 0;
}