Exploration
Accepts: 190
Submissions: 976
Time Limit: 30000/15000 MS (Java/Others)
Memory Limit: 131072/131072 K (Java/Others)
Problem Description
Miceren likes exploration and he found a huge labyrinth underground!
This labyrinth has NN caves and some tunnels connecting some pairs of caves.
There are two types of tunnel, one type of them can be passed in only one direction and the other can be passed in two directions. Tunnels will collapse immediately after Miceren passing them.
Now, Miceren wants to choose a cave as his start point and visit at least one other cave, finally get back to start point.
As his friend, you must help him to determine whether a start point satisfing his request exists.
Input
The first line contains a single integer TT, indicating the number of test cases.
Each test case begins with three integers N,~M1,~M2N, M1, M2, indicating the number of caves, the number of undirectional tunnels, the number of directional tunnels.
The next M1M1 lines contain the details of the undirectional tunnels. Each line contains two integers u,~vu, v meaning that there is a undirectional tunnel between u,~vu, v. (u~\neq~vu ≠ v)
The next M2M2 lines contain the details of the directional tunnels. Each line contains integers u,~vu, v meaning that there is a directional tunnel from uu to vv. (u~\neq~vu ≠ v)
TT is about 100.
1~\le~N, M1, M2~\le~1000000.1 ≤ N,M1,M2 ≤ 1000000.
There may be some tunnels connect the same pair of caves.
The ratio of test cases with $N~\gt~1000$ is less than 5%.
Output
For each test queries, print the answer. If Miceren can do that, output "YES", otherwise "NO".
Sample Input
2 5 2 1 1 2 1 2 4 5 4 2 2 1 2 2 3 4 3 4 1
Sample Output
YES NO
Hint
If you need a larger stack size, please use #pragma comment(linker, "/STACK:102400000,102400000") and submit your solution using C++.
思路：并查集+拓扑排序;
先处理无向边，用并查集缩点，然后处理完后，所有的无向边都没了，并且无向边所连的点都缩成一个点，那么剩下的就是有向图了，那么有向图判环用拓扑排序。
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include<iostream>
4 #include<algorithm>
5 #include<math.h>
6 #include<string.h>
7 #include<map>
8 #include<vector>
9 #include<queue>
10 using namespace std;
11 #pragma comment(linker, "/STACK:102400000,102400000")
12 typedef long long LL;
13 int bin[1000005];
14 int du[1000005];
15 vector<int>vec[1000005];
16 queue<int>que;
17 int id[1000005];
18 bool dfs(int n);
19 int fin(int x);
20 int cnt[1000005];
21 bool t[1000005];
22 int main(void)
23 {
24 int n;
25 scanf("%d",&n);
26 while(n--)
27 {
28 int i,j;
29 memset(cnt,0,sizeof(cnt));
30 memset(t,0,sizeof(t));
31 for(i = 0; i <= 1000000; i++)
32 {
33 bin[i] = i;
34 du[i] = 1;
35 vec[i].clear();
36 }
37 int N,m1,m2;
38 bool flag = false;
39 scanf("%d %d %d",&N,&m1,&m2);
40 while(m1--)
41 {
42 int a,b;
43 scanf("%d %d",&a,&b);
44 int aa = fin(a);
45 int bb = fin(b);
46 if(aa!=bb)
47 {
48 if(du[aa]>du[bb])
49 {
50 du[aa]+=du[bb];
51 bin[bb] = aa;
52 }
53 else
54 {
55 du[bb] += du[aa];
56 bin[aa] = bb;
57 }
58 }
59 else flag = true;
60 }
61 while(m2--)
62 {
63 int a,b;
64 scanf("%d %d",&a,&b);
65 if(!flag)
66 {
67 int aa = fin(a);
68 int bb = fin(b);
69 if(aa == bb)
70 flag = true;
71 else
72 { cnt[bb]++;
73 vec[aa].push_back(bb);
74 }
75 }
76 }
77 if(!flag)
78 {
79 int cn = 0;
80 for(i = 1; i <= N; i++)
81 {
82 int c = fin(i);
83 if(!t[c])
84 {
85 id[cn++] =c;
86 t[c] = true;
87 }
88 }
89 while(!que.empty())que.pop();
90 int ck = 0;
91 for(i = 0;i < cn;i++)
92 {
93 if(!cnt[id[i]])
94 {
95 que.push(id[i]);
96 ck++;
97 }
98 }
99 while(!que.empty())
100 {
101 int ff = que.front();
102 que.pop();
103 for(i = 0;i < vec[ff].size();i++)
104 {
105 int k = vec[ff][i];
106 cnt[k]--;
107 if(cnt[k] == 0)
108 ck++,que.push(k);
109 }
110 }
111 if(cn != ck)
112 flag = true;
113 }
114 if(flag)printf("YES\n");
115 else printf("NO\n");
116 }
117 return 0;
118 }
119 int fin(int x)
120 {
121 int i;
122 for(i = x; bin[i] != i;)
123 i = bin[i];
124 return i;
125 }
还有拓扑排序部分改成dfs也可以过，数据比较水。
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include<iostream>
4 #include<algorithm>
5 #include<math.h>
6 #include<string.h>
7 #include<map>
8 #include<vector>
9 using namespace std;
10 #pragma comment(linker, "/STACK:102400000,102400000")
11 typedef long long LL;
12 int bin[1000005];
13 int du[1000005];
14 vector<int>vec[1000005];
15 bool vis[1000005];
16 int id[1000005];
17 bool t[1000005];
18 bool dfs(int n);
19 int fin(int x);
20 int cnt[1000005];
21 int main(void)
22 {
23 int n;
24 scanf("%d",&n);
25 while(n--)
26 {
27 int i,j;
28 memset(vis,0,sizeof(vis));
29 memset(t,0,sizeof(t));
30 memset(cnt,0,sizeof(cnt));
31 for(i = 0; i <= 1000000; i++)
32 {
33 bin[i] = i;
34 du[i] = 1;
35 vec[i].clear();
36 }
37 int N,m1,m2;
38 bool flag = false;
39 scanf("%d %d %d",&N,&m1,&m2);
40 while(m1--)
41 {
42 int a,b;
43 scanf("%d %d",&a,&b);
44 int aa = fin(a);
45 int bb = fin(b);
46 if(aa!=bb)
47 {
48 if(du[aa]>du[bb])
49 {
50 du[aa]+=du[bb];
51 bin[bb] = aa;
52 }
53 else
54 {
55 du[bb] += du[aa];
56 bin[aa] = bb;
57 }
58 }
59 else flag = true;
60 }
61 while(m2--)
62 {
63 int a,b;
64 scanf("%d %d",&a,&b);
65 if(!flag)
66 {
67 int aa = fin(a);
68 int bb = fin(b);
69 if(aa == bb)
70 flag = true;
71 else
72 {
73 vec[aa].push_back(bb);
74 }
75 }
76 }
77 if(!flag)
78 {
79 int cn = 0;
80 for(i = 1; i <= N; i++)
81 {
82 int c = fin(i);
83 if(!t[c])
84 {
85 id[cn++] =c;
86 }
87 }
88 for(i = 0; i <= cn; i++)
89 {
90 if(!vis[id[i]])
91 {
92 flag = dfs(id[i]);
93 if(flag)break;
94 }
95 }
96 }
97 if(flag)printf("YES\n");
98 else printf("NO\n");
99 }
100 return 0;
101 }
102 int fin(int x)
103 {
104 int i;
105 for(i = x; bin[i] != i;)
106 i = bin[i];
107 return i;
108 }
109 bool dfs(int n)
110 {
111 cnt[n] = 1;
112 vis[n] = true;
113 for(int i = 0; i < vec[n].size(); i++)
114 {
115 int c = vec[n][i];
116 if(cnt[c] == 1)
117 {
118 cnt[c] = 0;
119 return true;
120 }
121 else
122 {
123 if(dfs(c))
124 {
125 cnt[c] = 0;
126 return true;
127 }
128 }
129 }
130 cnt[n] = 0;
131 return false;
132 }