QOJ.ac
QOJ
| ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
|---|---|---|---|---|---|---|---|---|---|
| #35340 | #961. Smol Vertex Cover | Froggygua | WA | 1024ms | 8580kb | C++17 | 2.4kb | 2022-06-15 11:30:28 | 2022-06-15 11:30:30 |
Judging History
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;
}
详细
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