[BZOJ3108][CQOI2013]图的逆变换(Bitset)

3108: [cqoi2013]图的逆变换

Time Limit: 10 Sec   Memory Limit: 128 MB

给一个n结点m条边的有向图D，可以这样构造图E：给D的每条边u->v，在E中建立一个点uv，然后对于D中的两条边u->v和v->w，在E中从uv向vw连一条有向边。E中不含有其他点和边。

输入E，你的任务是判断是否存在相应的D。注意，D可以有重边和自环。

 

Input

第一行包含测试数据个数T（T<=10）。每组数据前两行为D的边数（即E的点数）m和E的边数k（0<=m<=300）。以下k行每行两个整数x, y，表示E中有一条有向边x->y。E中的点编号为0~m-1。

 

Output

 

对于每组数据输出一行。如果存在，输出Yes，否则输出No。

Sample Input

4
2
1
0 1
5
0
4
3
0 1
2 1
2 3
3
9
0 1
0 2
1 2
1 0
2 0
2 1
0 0
1 1
2 2

Sample Output

Yes
Yes
No
Yes

思路&&分析：

    通过分析我们可以很清楚得发现，如果在图E上有两个点可以同时到达一个点，那么这两个点可以到达的点的点集肯定是一样的（非常容易证对吧，那我就不证了）。于是我们可以对于图E建一个反图，然后枚举每个点，看他可以到达几个点，然后这些点在图E上可达的点集必须是相同的，如果不相同那就是No，如果都相同那么就是Yes。于是我用了一个Bitset来存储图E上每个点可达的点，需要检查两个点的时候直接and一下看看与原来是否相同就行了。由于范围是很小的，那么直接暴力就行了。

Code

#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
bool Finish_read;
template<class T>inline void read(T &x){Finish_read=0;x=0;int f=1;char ch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;if(ch==EOF)return;ch=getchar();}while(isdigit(ch))x=x*10+ch-'0',ch=getchar();x*=f;Finish_read=1;}
template<class T>inline void print(T x){if(x/10!=0)print(x/10);putchar(x%10+'0');}
template<class T>inline void writeln(T x){if(x<0)putchar('-');x=abs(x);print(x);putchar('\n');}
template<class T>inline void write(T x){if(x<0)putchar('-');x=abs(x);print(x);}
/*================Header Template==============*/
int T,m,k;
bitset<305>G[305],R[305];
vector<int>L[305],F[305];
int main() {
    read(T);
    while(T--) {
        read(m);read(k);
        for(int i=1;i<=m;i++)
            G[i].reset(),R[i].reset(),L[i].clear(),F[i].clear();
        for(int i=1,u,v;i<=k;i++) {
            read(u);read(v);u++;v++;
            G[u][v]=1;
            R[v][u]=1;
            L[u].push_back(v);
            F[v].push_back(u);
        }
        bool can=1;
        for(int i=1;i<=m;i++) {
            if(L[i].size()>=2) {
                for(unsigned j=0;j<L[i].size();j++) {
                    int t=L[i][j];
                    for(unsigned k=0;k<F[t].size();k++) {
                        int v=F[t][k];
                        if(max(G[v].count(),G[i].count())!=(G[v]&G[i]).count())
                            can=0;
                        if(!can)
                            break;
                    }
                    if(!can)
                        break;
                }
            }
            if(!can)
                break;
        }
        puts(can?"Yes":"No");
    }
}