QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#35340#961. Smol Vertex CoverFroggyguaWA 1024ms8580kbC++172.4kb2022-06-15 11:30:282022-06-15 11:30:30

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2022-06-15 11:30:30]
  • 评测
  • 测评结果:WA
  • 用时:1024ms
  • 内存:8580kb
  • [2022-06-15 11:30:28]
  • 提交

answer

#include<bits/stdc++.h>
using namespace std;
#define N 505
typedef long long ll;
mt19937 rnd(time(0));
int n,m,Ans,mat[N];
vector<int> G[N];
bitset<N> bk;
bool dfs(int u){
	shuffle(G[u].begin(),G[u].end(),rnd);
	bk[u]=1;
	for(auto v:G[u]){
		if(bk[mat[v]])continue;
		int t=mat[v];
		mat[u]=v,mat[v]=u,mat[t]=0;
		if(!t||dfs(t))return true;
		mat[u]=0,mat[v]=t,mat[t]=v;
	}
	return false;
}
int get_match(){
	int tot=0;
	for(int T=1;T<=5;++T){
		for(int i=1;i<=n;++i){
			if(!mat[i]){
				bk.reset();
				tot+=dfs(i);
			}
		}
	}
	return tot;
}
vector<int> H[N];
int id[N],p[N];
int dfn[N],low[N],num,tot,col[N];
bool vis[N];
inline int yes(int x){return 2*x+1;}
inline int no(int x){return 2*x;}
inline void adde(int u,int v){
	H[u].push_back(v);
	H[v^1].push_back(u^1);
}
void Clear(int n){
	for(int i=1;i<=n;++i){
		dfn[i]=low[i]=vis[i]=col[i]=0;
	}
	num=tot=0;
}
void Tarjan(int u){
	static int st[N],top;
	dfn[u]=low[u]=++num;
	vis[u]=1;
	st[++top]=u;
	for(auto v:H[u]){
		if(!dfn[v]){
			Tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(vis[v]){
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(dfn[u]==low[u]){
		int t=0;
		++tot;
		while(t^u){
			t=st[top--];
			vis[t]=0;
			col[t]=tot;
		}
	}
}
bool check(){
	Clear(n);
	for(int i=1;i<=n;++i){
		if(!dfn[i])Tarjan(i);
	}
	for(int i=1;i<=Ans;++i){
		if(col[yes(i)]==col[no(i)]){
			return false;
		}
	}
	return true;
}
void Do(int z){
	for(int i=1;i<=n;++i){
		H[i].clear();
	}
	if(id[z]){
		adde(id[z]^1,id[z]);
	}
	for(int u=1;u<=n;++u){
		if(u==z)continue;
		for(auto v:G[u]){
			if(v==z)continue;
			if(!id[u]&&!id[v]){
				return;
			}
			if(!id[u]){
				adde(id[v]^1,id[v]);
			}
			else if(!id[v]){
				adde(id[u]^1,id[u]);
			}
			else{
				if((id[u]^1)==id[v])continue;
				adde(id[u]^1,id[v]);
			}
		}
	}
	if(check()){
		cout<<Ans+(z>0)<<'\n';
		if(z)cout<<z<<' ';
		for(int i=1;i<=Ans;++i){
			cout<<(col[yes(i)]<col[no(i)]?p[yes(i)]:p[no(i)])<<' ';
		}
		exit(0);
	}
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>m;
	for(int i=1;i<=m;++i){
		int u,v;
		cin>>u>>v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
	Ans=get_match();
	for(int i=1,e=2;i<=n;++i){
		if(!mat[i]||id[i])continue;
		p[id[i]=e++]=i;
		p[id[mat[i]]=e++]=mat[i];
	}
	Do(0);
	for(int i=1;i<=n;++i){
		Do(i);
	}
	cout<<"not smol\n";
	return 0;
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 1ms
memory: 3668kb

input:

5 5
1 2
2 3
3 4
4 5
1 5

output:

3
5 1 3 

result:

ok vertex cover of size 3

Test #2:

score: 0
Accepted
time: 2ms
memory: 3552kb

input:

5 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5

output:

not smol

result:

ok not smol

Test #3:

score: 0
Accepted
time: 2ms
memory: 3616kb

input:

3 0

output:

0

result:

ok vertex cover of size 0

Test #4:

score: 0
Accepted
time: 1ms
memory: 3724kb

input:

10 10
2 5
3 8
3 10
6 9
1 4
2 6
2 3
4 6
7 10
4 7

output:

5
1 2 3 6 7 

result:

ok vertex cover of size 5

Test #5:

score: 0
Accepted
time: 2ms
memory: 3664kb

input:

10 20
1 9
3 6
3 7
8 9
3 8
1 4
5 10
7 10
4 6
7 9
9 10
2 7
1 6
5 8
2 9
1 7
5 7
3 10
2 6
4 10

output:

6
8 1 7 6 10 9 

result:

ok vertex cover of size 6

Test #6:

score: 0
Accepted
time: 2ms
memory: 3636kb

input:

50 100
29 49
1 43
12 49
31 46
6 42
25 29
27 37
2 39
3 43
34 43
4 38
2 40
9 14
7 20
22 31
9 42
3 31
36 49
23 33
17 18
34 47
20 36
11 24
5 17
6 29
21 22
5 41
19 28
31 37
8 47
8 42
8 28
1 48
31 41
6 32
14 36
32 42
27 47
1 40
6 30
26 49
9 44
12 22
30 46
9 11
11 28
18 32
13 15
17 44
16 29
17 42
4 21
17 2...

output:

not smol

result:

ok not smol

Test #7:

score: 0
Accepted
time: 2ms
memory: 3668kb

input:

50 300
18 29
25 33
13 27
22 38
43 50
9 47
36 43
15 33
33 36
23 39
17 46
28 35
40 49
24 26
15 30
39 43
9 48
2 4
7 20
13 21
35 40
2 46
12 22
17 33
9 49
17 32
15 28
24 32
7 38
12 32
18 37
13 30
4 24
5 22
6 17
4 26
3 13
5 29
27 34
1 12
16 22
3 14
1 21
22 27
20 49
9 34
18 36
40 42
21 33
44 45
2 49
13 37
...

output:

not smol

result:

ok not smol

Test #8:

score: 0
Accepted
time: 3ms
memory: 3740kb

input:

50 1000
3 35
32 34
2 24
3 10
15 34
9 45
16 24
7 10
15 39
38 40
17 45
21 35
18 36
15 50
22 29
34 40
3 36
43 50
17 19
7 30
27 44
12 48
9 18
14 20
16 30
1 34
20 35
19 33
2 27
13 20
19 32
38 48
27 37
4 28
5 45
6 43
1 36
9 13
4 18
14 32
10 38
3 44
8 47
6 41
18 38
13 40
18 28
40 47
15 18
42 48
15 47
31 36...

output:

not smol

result:

ok not smol

Test #9:

score: 0
Accepted
time: 3ms
memory: 3652kb

input:

200 300
64 134
92 154
82 142
33 198
26 185
24 74
32 144
26 118
113 122
98 130
74 84
70 184
45 181
44 136
44 134
67 185
77 160
21 50
80 181
62 78
196 199
37 174
91 105
17 74
158 166
26 172
70 129
128 133
152 173
15 86
37 67
55 91
45 74
60 141
179 184
22 168
65 161
62 67
117 152
174 181
35 99
80 103
3...

output:

not smol

result:

ok not smol

Test #10:

score: 0
Accepted
time: 6ms
memory: 3772kb

input:

200 1000
19 159
64 180
15 88
82 136
22 57
92 200
86 87
176 194
57 106
116 179
101 128
27 137
41 71
35 139
48 153
177 178
80 131
9 156
29 122
101 148
88 163
90 116
16 72
8 166
100 116
97 161
19 143
78 163
23 119
104 146
91 161
52 66
183 196
29 123
84 86
41 109
65 76
82 161
138 182
108 156
35 94
101 1...

output:

not smol

result:

ok not smol

Test #11:

score: 0
Accepted
time: 19ms
memory: 3956kb

input:

200 5000
60 81
22 145
156 181
27 44
49 89
69 176
61 64
16 199
46 50
75 103
26 168
6 35
60 75
51 117
41 105
20 154
69 100
75 195
22 115
67 72
170 190
31 115
10 200
51 129
14 147
161 163
9 72
22 113
70 87
112 184
28 81
178 197
72 180
171 192
71 116
71 174
30 95
20 157
50 125
142 184
18 130
82 110
65 1...

output:

not smol

result:

ok not smol

Test #12:

score: 0
Accepted
time: 2ms
memory: 3744kb

input:

500 300
201 309
17 37
39 176
416 493
86 475
163 215
127 283
122 274
107 412
7 93
294 434
335 360
50 87
364 372
55 192
341 411
236 299
286 349
79 208
137 470
141 421
21 324
4 165
232 473
367 397
400 475
30 77
177 435
116 133
115 281
416 482
198 498
300 410
173 457
176 450
157 179
402 425
219 486
39 3...

output:

147
3 4 5 6 7 94 12 354 399 17 18 20 21 22 410 24 202 181 30 32 34 39 109 43 44 242 46 151 86 49 50 285 52 54 55 394 481 313 60 64 459 67 68 483 188 73 76 78 208 294 82 85 91 92 95 96 99 101 201 107 395 110 113 183 471 116 118 120 121 122 443 127 231 345 159 470 140 421 403 146 370 152 179 158 160 2...

result:

ok vertex cover of size 147

Test #13:

score: 0
Accepted
time: 13ms
memory: 3660kb

input:

500 1000
232 237
263 478
147 353
131 318
45 109
218 452
377 436
61 326
29 372
394 484
72 374
312 449
451 461
26 113
25 188
21 282
453 484
261 295
449 489
225 422
125 168
123 449
23 211
251 484
40 185
38 304
6 337
71 142
287 356
315 413
185 411
68 111
453 457
70 187
20 183
107 361
324 466
277 483
10 ...

output:

not smol

result:

ok not smol

Test #14:

score: 0
Accepted
time: 47ms
memory: 4092kb

input:

500 5000
78 84
13 468
95 135
258 447
258 267
226 321
132 282
238 355
194 248
75 485
325 390
46 182
156 284
272 289
204 361
15 228
322 448
410 430
35 317
227 386
325 398
207 443
36 280
73 153
117 459
396 494
234 430
140 199
49 357
26 128
177 210
15 231
351 379
357 484
299 489
376 454
177 377
228 331
...

output:

not smol

result:

ok not smol

Test #15:

score: 0
Accepted
time: 1024ms
memory: 8580kb

input:

500 124750
260 435
24 351
41 342
79 458
63 342
463 485
313 372
88 486
300 435
144 440
88 480
83 373
126 356
129 486
118 416
83 138
439 447
59 222
1 162
367 487
137 286
253 261
255 451
329 461
276 328
66 184
76 441
228 492
93 396
288 420
2 424
257 318
216 342
249 474
152 200
206 485
13 332
353 406
20...

output:

not smol

result:

ok not smol

Test #16:

score: 0
Accepted
time: 2ms
memory: 3664kb

input:

20 20
12 17
15 18
14 20
3 19
11 12
5 14
6 20
2 6
13 19
6 18
3 20
13 18
8 19
1 9
4 12
1 5
10 14
10 13
10 12
7 11

output:

9
1 2 20 12 5 11 19 10 18 

result:

ok vertex cover of size 9

Test #17:

score: 0
Accepted
time: 1ms
memory: 3660kb

input:

20 40
5 12
10 17
9 15
4 7
8 17
11 12
6 16
8 11
1 15
14 18
9 17
1 6
8 14
3 5
10 15
4 18
3 20
9 14
7 19
2 12
9 19
6 18
10 20
4 13
3 14
4 8
17 18
3 15
18 20
1 17
5 9
7 14
4 9
7 20
6 7
2 7
8 15
13 15
4 16
2 18

output:

10
1 18 3 16 12 7 8 9 10 13 

result:

ok vertex cover of size 10

Test #18:

score: 0
Accepted
time: 1ms
memory: 3632kb

input:

20 70
3 4
4 8
7 17
2 7
5 7
3 15
1 16
5 10
13 20
10 19
7 15
8 9
6 16
11 20
18 19
3 5
6 17
1 5
9 11
4 12
15 18
1 15
18 20
5 18
8 14
1 14
10 20
8 17
7 9
13 14
6 14
11 19
4 7
5 8
13 19
4 6
6 9
2 18
10 14
2 10
6 20
12 14
10 15
2 8
1 19
14 18
11 17
3 9
16 18
1 17
11 16
6 19
7 19
13 16
8 19
7 14
12 15
1 2
...

output:

10
1 3 11 13 6 7 8 10 12 18 

result:

ok vertex cover of size 10

Test #19:

score: 0
Accepted
time: 2ms
memory: 3644kb

input:

110 50
48 64
54 66
9 76
53 54
54 99
50 100
98 100
48 83
48 63
16 103
87 110
14 110
45 57
71 103
99 103
11 54
38 110
57 102
29 110
2 107
44 110
94 100
9 46
24 32
47 88
36 57
24 34
63 100
12 48
59 103
9 15
2 103
21 57
54 62
12 103
47 108
11 107
54 106
47 75
9 64
24 95
38 100
78 107
48 60
2 9
9 59
39 4...

output:

10
110 103 9 54 48 57 24 100 47 107 

result:

ok vertex cover of size 10

Test #20:

score: 0
Accepted
time: 2ms
memory: 3720kb

input:

110 300
43 59
21 78
41 53
8 37
51 55
10 58
36 81
51 105
8 104
69 101
15 84
8 29
4 69
8 83
53 54
51 54
64 69
61 69
50 53
15 46
43 47
51 108
29 69
57 81
16 18
51 109
8 99
18 37
1 43
10 96
15 95
10 14
15 107
8 50
36 51
51 78
81 94
10 66
12 51
69 102
43 63
27 81
8 72
15 44
14 53
43 54
28 69
43 68
69 108...

output:

10
53 21 15 18 51 10 8 69 81 43 

result:

ok vertex cover of size 10

Test #21:

score: 0
Accepted
time: 2ms
memory: 3764kb

input:

110 700
42 93
34 45
52 109
26 102
34 100
34 43
57 87
33 34
25 88
42 50
34 62
36 95
60 106
21 87
81 87
99 106
42 56
1 8
78 87
25 48
42 43
8 68
8 104
14 42
13 34
35 109
99 109
39 42
35 102
26 106
42 57
22 42
97 102
1 95
95 100
45 102
31 102
22 34
59 87
82 96
20 106
25 69
8 77
13 25
25 63
49 96
34 57
8...

output:

10
42 95 102 109 96 8 25 34 106 87 

result:

ok vertex cover of size 10

Test #22:

score: 0
Accepted
time: 2ms
memory: 3696kb

input:

200 500
9 78
21 41
6 189
106 172
73 198
124 154
71 111
24 77
3 22
193 194
143 187
147 192
11 127
35 49
5 60
139 161
52 96
14 51
28 163
57 105
12 154
155 159
153 187
130 133
71 132
15 95
5 29
119 153
78 96
117 159
69 170
180 188
147 151
28 62
3 142
52 77
1 192
62 68
75 135
8 191
145 187
114 157
91 14...

output:

100
1 164 3 4 5 52 7 124 121 10 12 185 147 15 91 100 81 137 20 88 72 61 24 25 26 128 135 45 32 142 49 117 37 38 39 167 41 42 43 44 46 47 125 51 158 55 105 64 132 62 63 65 174 67 170 109 87 73 84 171 78 127 184 144 150 86 89 90 145 93 139 104 195 106 173 122 112 111 118 116 119 123 126 129 130 186 15...

result:

ok vertex cover of size 100

Test #23:

score: 0
Accepted
time: 0ms
memory: 3816kb

input:

200 3000
109 154
86 90
5 157
30 132
114 162
133 160
88 151
40 112
33 36
76 142
69 171
81 118
115 144
65 128
33 192
178 182
44 91
51 98
94 111
29 122
62 109
8 72
122 195
165 175
74 104
116 126
94 114
139 170
6 192
168 169
67 190
59 64
110 186
62 148
49 180
33 141
81 88
102 165
1 120
116 180
33 111
34...

output:

100
1 118 3 4 58 155 133 8 26 197 11 12 157 31 46 16 91 103 19 29 128 164 23 24 25 27 28 30 186 143 35 36 165 169 45 184 43 111 161 48 49 158 51 53 75 55 57 70 60 61 62 64 80 174 71 147 73 85 142 108 78 101 176 82 83 191 86 87 88 89 199 173 193 135 104 105 115 114 112 113 116 185 119 179 189 195 172...

result:

ok vertex cover of size 100

Test #24:

score: 0
Accepted
time: 4ms
memory: 3976kb

input:

200 8000
149 157
84 176
17 73
100 132
25 181
171 200
16 35
5 78
97 126
113 171
24 184
117 143
40 108
96 192
9 139
109 179
101 161
114 127
156 167
14 161
128 156
71 190
51 183
51 140
74 104
119 151
65 71
158 174
138 161
160 192
9 158
27 67
55 162
100 102
159 174
63 81
47 195
40 148
36 121
107 181
33 ...

output:

100
1 2 41 5 89 7 85 62 10 11 109 19 133 100 16 20 81 21 29 135 24 126 98 79 28 30 31 32 190 128 127 36 37 38 129 42 159 148 115 46 181 167 182 105 52 54 146 196 57 58 59 60 61 164 152 65 67 118 69 161 178 72 73 171 75 158 192 80 83 86 169 91 141 194 199 120 112 155 163 104 139 117 108 110 111 119 1...

result:

ok vertex cover of size 100

Test #25:

score: 0
Accepted
time: 3ms
memory: 3724kb

input:

500 500
271 342
280 463
424 444
322 342
200 239
239 358
449 469
239 269
54 63
98 342
375 488
245 449
338 342
18 63
188 359
274 280
3 449
239 241
75 239
42 239
280 425
375 486
8 280
95 388
321 342
39 280
95 487
219 449
188 312
188 417
270 424
92 375
264 280
59 280
188 444
79 399
188 418
320 424
156 3...

output:

10
188 424 63 399 280 239 95 449 375 342 

result:

ok vertex cover of size 10

Test #26:

score: 0
Accepted
time: 3ms
memory: 3816kb

input:

500 1000
9 316
133 491
9 89
55 82
247 480
133 364
139 317
168 411
60 168
339 365
247 279
72 488
55 160
5 339
247 343
60 81
247 483
55 76
139 494
168 374
168 215
21 339
81 500
81 374
143 391
55 207
37 55
168 253
205 391
9 92
2 168
9 70
55 441
9 278
168 335
437 488
9 396
391 411
55 318
81 161
2 247
27...

output:

10
488 168 247 391 339 81 133 139 9 55 

result:

ok vertex cover of size 10

Test #27:

score: 0
Accepted
time: 2ms
memory: 3876kb

input:

500 4000
34 440
276 370
287 292
23 449
23 400
34 179
44 317
23 115
30 34
276 388
88 129
276 415
165 300
123 249
300 445
122 287
276 431
283 484
30 283
23 169
276 460
170 270
164 283
123 397
23 263
129 175
208 287
300 315
170 292
66 170
287 375
126 276
287 441
287 487
88 287
300 418
262 276
44 206
11...

output:

10
300 276 283 287 170 23 129 44 34 123 

result:

ok vertex cover of size 10

Test #28:

score: 0
Accepted
time: 0ms
memory: 3756kb

input:

500 500
12 25
334 479
235 352
343 496
120 445
178 477
93 477
124 364
55 294
222 463
29 191
18 107
38 97
142 451
29 78
237 438
98 196
26 234
16 189
15 311
297 339
107 300
176 442
218 222
8 396
335 336
456 474
276 495
130 350
59 498
18 441
303 376
308 357
10 35
114 470
403 476
234 282
132 372
6 37
179...

output:

188
1 2 3 4 37 8 9 388 11 66 13 92 15 16 17 441 19 20 22 23 24 25 26 27 28 29 30 288 32 178 34 35 36 38 293 41 42 43 44 45 46 47 348 332 52 424 487 294 56 57 59 390 328 291 377 217 65 196 71 420 213 419 75 237 137 79 234 81 112 408 113 86 483 257 93 94 436 381 97 100 157 324 103 421 105 107 139 109 ...

result:

ok vertex cover of size 188

Test #29:

score: 0
Accepted
time: 12ms
memory: 3760kb

input:

500 3000
27 174
78 179
309 321
33 313
219 225
203 316
30 149
266 270
106 350
369 463
74 433
54 398
82 296
276 430
291 419
122 412
343 427
76 163
113 398
147 482
113 263
56 411
383 396
115 149
161 276
130 207
163 297
191 283
2 68
25 419
120 414
133 409
308 321
235 476
89 176
46 130
80 113
293 405
52 ...

output:

200
1 472 168 4 469 197 287 470 452 327 225 12 190 14 310 16 476 146 19 20 266 23 25 437 27 28 428 30 488 32 364 215 236 36 37 462 210 464 313 42 129 253 198 46 490 48 484 50 51 400 53 196 184 56 57 58 274 403 343 62 63 223 372 208 499 68 199 71 72 73 433 495 76 77 78 80 207 211 307 371 92 87 387 17...

result:

ok vertex cover of size 200

Test #30:

score: 0
Accepted
time: 25ms
memory: 3820kb

input:

500 8000
94 339
209 235
86 449
123 181
230 282
69 341
199 324
21 194
7 72
36 379
75 234
73 84
233 379
148 377
32 56
5 264
111 453
246 475
32 96
202 433
235 328
49 298
104 346
349 427
243 484
104 380
10 477
303 318
57 90
84 347
65 442
188 212
318 323
283 404
127 463
26 490
58 160
430 456
21 147
5 35
...

output:

200
1 234 3 4 5 6 7 121 9 10 11 12 13 14 15 478 141 19 89 21 423 23 24 365 26 27 28 379 30 31 32 327 34 410 412 209 39 224 283 125 43 316 92 168 385 48 160 51 328 83 54 336 456 59 60 123 63 273 212 258 426 68 69 115 146 102 270 76 500 78 79 93 448 200 84 85 86 203 377 90 91 94 95 322 281 199 307 104...

result:

ok vertex cover of size 200

Test #31:

score: 0
Accepted
time: 53ms
memory: 4396kb

input:

500 20000
280 430
283 415
147 154
343 433
59 417
47 474
14 204
56 80
193 416
296 484
112 140
193 291
147 238
98 255
106 358
39 424
8 295
309 370
96 132
68 432
237 454
69 119
98 218
308 343
12 372
105 272
147 421
108 110
121 161
16 44
225 286
17 328
327 329
72 170
52 260
295 302
170 347
20 281
37 66
...

output:

200
1 390 406 4 352 500 491 268 215 10 262 12 386 272 15 408 123 293 19 46 86 449 23 71 133 384 27 87 31 65 325 317 34 337 36 72 191 39 464 497 42 44 203 47 48 186 51 52 165 172 347 140 270 58 66 483 197 62 338 305 67 375 383 290 373 447 136 365 299 78 403 80 90 455 83 119 85 314 89 391 92 321 94 35...

result:

ok vertex cover of size 200

Test #32:

score: 0
Accepted
time: 134ms
memory: 5324kb

input:

500 50000
103 130
189 432
290 497
46 337
113 237
249 333
162 376
181 272
30 101
58 192
252 362
374 424
85 322
201 432
163 340
74 99
69 424
189 416
160 343
235 425
70 304
50 322
21 370
38 338
395 469
141 468
146 471
282 497
249 265
131 292
6 417
239 326
243 347
155 167
130 209
17 302
189 222
100 291
...

output:

200
369 172 54 4 5 394 37 292 229 10 288 81 13 14 142 16 17 18 19 20 83 22 162 219 129 26 481 339 378 30 31 32 33 388 132 36 396 469 40 260 42 105 44 45 46 76 375 49 404 192 417 454 392 72 391 88 120 60 269 62 63 460 65 482 67 80 124 70 71 466 338 213 82 485 258 175 280 89 240 310 92 93 94 397 96 21...

result:

ok vertex cover of size 200

Test #33:

score: 0
Accepted
time: 2ms
memory: 3592kb

input:

10 20
8 9
1 4
7 9
9 10
3 4
2 4
2 9
4 9
2 7
6 9
2 6
4 10
2 3
1 2
5 9
4 6
4 5
2 8
4 8
2 5

output:

3
2 4 9 

result:

ok vertex cover of size 3

Test #34:

score: 0
Accepted
time: 2ms
memory: 3596kb

input:

10 15
6 10
7 10
6 7
3 7
2 3
8 10
2 8
4 10
4 7
1 7
2 9
7 8
2 7
2 6
2 10

output:

3
7 2 10 

result:

ok vertex cover of size 3

Test #35:

score: -100
Wrong Answer
time: 2ms
memory: 3616kb

input:

10 33
1 4
1 3
4 6
3 10
1 9
6 7
4 10
3 8
4 5
8 10
7 9
3 7
4 8
6 8
2 4
4 7
9 10
2 7
2 5
2 8
7 10
2 10
1 6
8 9
5 10
6 10
2 3
2 9
1 8
1 10
3 4
7 8
1 2

output:

not smol

result:

wrong answer vertex cover is smol, but participant did not print it