oj.uz

Submission #288201

# Submission time Handle Problem Language Result Execution time Memory
288201 2020-09-01T09:56:48 Z user202729 Simurgh (IOI17_simurgh) C++17
51 / 100
 173 ms 4320 KB 
// moreflags=grader.cpp
// 11
#include "simurgh.h"
#if not LOCAL
#define NDEBUG
#endif
#include<cassert>
#include<algorithm>

struct Dsu{
	std::vector<int> data;
	Dsu(int number){reset(number);}
	void reset(int number){data.assign(number, -1);}
	int root(int node){return data[node]>=0 ? data[node]=root(data[node]): node;}
	bool join(int first, int sec){
		first=root(first); sec=root(sec);
		if(first==sec) return false;
		data[first]=sec;
		return true;
	}
};

struct Edge{int node, index;};
std::vector<std::vector<Edge>> add;
std::vector<int> par, depth, parIndex;
std::vector<char> visited;

void work(int node, int curPar, int curDepth){
	par[node]=curPar; depth[node]=curDepth;
	assert(not visited[node]); visited[node]=true;
	for(auto [child, index]: add[node]) if(not visited[child]){
		parIndex[child]=index;
		work(child, node, curDepth+1);
	}
}

std::vector<int> find_roads(int n, std::vector<int> u, std::vector<int> v) {
	// construct a DFS tree
	add.resize(n);
	for(int index=0; index<(int)u.size(); ++index){
		auto const first=u[index], sec=v[index];
		add[first].push_back({sec, index});
		add[sec].push_back({first, index});
	}
	par.resize(n); depth.resize(n);
	visited.assign(n, false);
	parIndex.resize(n); parIndex[0]=-1;
	work(0, -1, 0);

	// compute value of that tree
	std::vector<int> tmp; tmp.reserve(n-1);
	for(int node=0; node<n; ++node)
		for(auto [other, index]: add[node]) if(depth[other]==depth[node]-1)
			tmp.push_back(index);
	int const treeValue=count_common_roads(tmp);

	// compute individual edges' values
	std::vector<int> value(u.size(), -1);
	for(int node=0; node<n; ++node){
		for(auto [other, backIndex]: add[node]) if(depth[other]<depth[node]-1){
			// back edge
			int& backValue=value[backIndex];
			assert(backValue==-1);

			/*
			for(int x=node; x!=other; x=par[x]){
				if(value[parIndex[x]]<0) goto anyUndefined;
			}
			continue;
			*/

anyUndefined:
			bool guessBackValue=true;
			backValue=0; // this is the guess.
			for(int x=node; x!=other; x=par[x]){
				int& curValue=value[parIndex[x]];
				if(guessBackValue or curValue<0){
					auto const iterator=std::find(begin(tmp), end(tmp), parIndex[x]);
					*iterator=backIndex;
					auto const v=count_common_roads(tmp)-treeValue; // == backValue-curValue
					*iterator=parIndex[x];

					switch(v){
						case 0:
							{
								if(curValue>=0){
									if(guessBackValue){
										assert(backValue==0); backValue=curValue;
										guessBackValue=false;
									}else{
										assert(curValue==backValue);
									}
								}else{
									curValue=backValue;
								}
								break;
							}
						case -1:
							{
								assert(curValue!=0); curValue=1;
								assert(backValue==0);
								if(guessBackValue){
									guessBackValue=false; // already guessed correctly
								}
								break;
							}
						case 1:
							{
								assert(v==1);
								assert(curValue!=1);
								if(guessBackValue){ // guessed incorrectly, must fix values
									assert(backValue==0);
									backValue=1;

									for(int y=node; y!=x; y=par[y]){
										assert(value[parIndex[y]]==0); value[parIndex[y]]=1;
									}

								}else assert(backValue==1);
								curValue=0; backValue=1; guessBackValue=false;
								break;

							}
						default:
							assert(false); __builtin_unreachable();
					}
				}
			}

			if(guessBackValue){
				assert(backValue==0);
				for(int x=node; x!=other; x=par[x])
					assert(value[parIndex[x]]==0);
				// also guessed correctly (there's no way the values of all those edges can be 1 at the same time)
			}
		}
	}

	// double check that tmp is the DFS tree
	for(int node=0; node<n; ++node)
		for(auto [other, index]: add[node]) if(depth[other]==depth[node]-1){
			assert(std::find(begin(tmp), end(tmp), index)!=tmp.end());
		}

	for(auto index: tmp)
		if(value[index]==-1) value[index]=1; // a bridge

	tmp.clear();
	for(int index=0; index<(int)value.size(); ++index){
		assert(value[index]>=0);
		if(value[index]) tmp.push_back(index);
	}
	return tmp;
}

Compilation message

simurgh.cpp: In function 'std::vector<int> find_roads(int, std::vector<int>, std::vector<int>)':
simurgh.cpp:72:1: warning: label 'anyUndefined' defined but not used [-Wunused-label]
   72 | anyUndefined:
      | ^~~~~~~~~~~~

Subtask #1
13.0 / 13.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 256 KB correct
2 Correct 0 ms 256 KB correct
3 Correct 1 ms 256 KB correct
4 Correct 0 ms 256 KB correct
5 Correct 1 ms 256 KB correct
6 Correct 0 ms 256 KB correct
7 Correct 1 ms 256 KB correct
8 Correct 1 ms 256 KB correct
9 Correct 0 ms 256 KB correct
10 Correct 0 ms 256 KB correct
11 Correct 0 ms 256 KB correct
12 Correct 0 ms 256 KB correct
13 Correct 0 ms 256 KB correct

Subtask #2
17.0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 256 KB correct
2 Correct 0 ms 256 KB correct
3 Correct 1 ms 256 KB correct
4 Correct 0 ms 256 KB correct
5 Correct 1 ms 256 KB correct
6 Correct 0 ms 256 KB correct
7 Correct 1 ms 256 KB correct
8 Correct 1 ms 256 KB correct
9 Correct 0 ms 256 KB correct
10 Correct 0 ms 256 KB correct
11 Correct 0 ms 256 KB correct
12 Correct 0 ms 256 KB correct
13 Correct 0 ms 256 KB correct
14 Correct 2 ms 384 KB correct
15 Correct 2 ms 384 KB correct
16 Correct 2 ms 384 KB correct
17 Correct 2 ms 384 KB correct
18 Correct 1 ms 384 KB correct
19 Correct 2 ms 384 KB correct
20 Correct 2 ms 384 KB correct
21 Correct 2 ms 384 KB correct
22 Correct 1 ms 384 KB correct
23 Correct 1 ms 384 KB correct
24 Correct 1 ms 384 KB correct
25 Correct 0 ms 256 KB correct
26 Correct 1 ms 384 KB correct
27 Correct 2 ms 384 KB correct
28 Correct 1 ms 256 KB correct
29 Correct 1 ms 256 KB correct
30 Correct 1 ms 384 KB correct
31 Correct 1 ms 384 KB correct
32 Correct 1 ms 384 KB correct
33 Correct 1 ms 384 KB correct

Subtask #3
21.0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 256 KB correct
2 Correct 0 ms 256 KB correct
3 Correct 1 ms 256 KB correct
4 Correct 0 ms 256 KB correct
5 Correct 1 ms 256 KB correct
6 Correct 0 ms 256 KB correct
7 Correct 1 ms 256 KB correct
8 Correct 1 ms 256 KB correct
9 Correct 0 ms 256 KB correct
10 Correct 0 ms 256 KB correct
11 Correct 0 ms 256 KB correct
12 Correct 0 ms 256 KB correct
13 Correct 0 ms 256 KB correct
14 Correct 2 ms 384 KB correct
15 Correct 2 ms 384 KB correct
16 Correct 2 ms 384 KB correct
17 Correct 2 ms 384 KB correct
18 Correct 1 ms 384 KB correct
19 Correct 2 ms 384 KB correct
20 Correct 2 ms 384 KB correct
21 Correct 2 ms 384 KB correct
22 Correct 1 ms 384 KB correct
23 Correct 1 ms 384 KB correct
24 Correct 1 ms 384 KB correct
25 Correct 0 ms 256 KB correct
26 Correct 1 ms 384 KB correct
27 Correct 2 ms 384 KB correct
28 Correct 1 ms 256 KB correct
29 Correct 1 ms 256 KB correct
30 Correct 1 ms 384 KB correct
31 Correct 1 ms 384 KB correct
32 Correct 1 ms 384 KB correct
33 Correct 1 ms 384 KB correct
34 Correct 163 ms 1668 KB correct
35 Correct 167 ms 1636 KB correct
36 Correct 113 ms 1280 KB correct
37 Correct 8 ms 384 KB correct
38 Correct 169 ms 1656 KB correct
39 Correct 138 ms 1536 KB correct
40 Correct 109 ms 1400 KB correct
41 Correct 173 ms 1536 KB correct
42 Correct 162 ms 1664 KB correct
43 Correct 84 ms 1276 KB correct
44 Correct 69 ms 896 KB correct
45 Correct 82 ms 896 KB correct
46 Correct 62 ms 768 KB correct
47 Correct 27 ms 512 KB correct
48 Correct 2 ms 384 KB correct
49 Correct 8 ms 384 KB correct
50 Correct 26 ms 512 KB correct
51 Correct 80 ms 896 KB correct
52 Correct 70 ms 896 KB correct
53 Correct 62 ms 768 KB correct
54 Correct 87 ms 1152 KB correct
55 Correct 81 ms 1024 KB correct
56 Correct 82 ms 1024 KB correct
57 Correct 81 ms 1024 KB correct

Subtask #4
0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 256 KB correct
2 Correct 0 ms 256 KB correct
3 Incorrect 136 ms 4320 KB WA in grader: NO
4 Halted 0 ms 0 KB -

Subtask #5
0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 256 KB correct
2 Correct 0 ms 256 KB correct
3 Correct 1 ms 256 KB correct
4 Correct 0 ms 256 KB correct
5 Correct 1 ms 256 KB correct
6 Correct 0 ms 256 KB correct
7 Correct 1 ms 256 KB correct
8 Correct 1 ms 256 KB correct
9 Correct 0 ms 256 KB correct
10 Correct 0 ms 256 KB correct
11 Correct 0 ms 256 KB correct
12 Correct 0 ms 256 KB correct
13 Correct 0 ms 256 KB correct
14 Correct 2 ms 384 KB correct
15 Correct 2 ms 384 KB correct
16 Correct 2 ms 384 KB correct
17 Correct 2 ms 384 KB correct
18 Correct 1 ms 384 KB correct
19 Correct 2 ms 384 KB correct
20 Correct 2 ms 384 KB correct
21 Correct 2 ms 384 KB correct
22 Correct 1 ms 384 KB correct
23 Correct 1 ms 384 KB correct
24 Correct 1 ms 384 KB correct
25 Correct 0 ms 256 KB correct
26 Correct 1 ms 384 KB correct
27 Correct 2 ms 384 KB correct
28 Correct 1 ms 256 KB correct
29 Correct 1 ms 256 KB correct
30 Correct 1 ms 384 KB correct
31 Correct 1 ms 384 KB correct
32 Correct 1 ms 384 KB correct
33 Correct 1 ms 384 KB correct
34 Correct 163 ms 1668 KB correct
35 Correct 167 ms 1636 KB correct
36 Correct 113 ms 1280 KB correct
37 Correct 8 ms 384 KB correct
38 Correct 169 ms 1656 KB correct
39 Correct 138 ms 1536 KB correct
40 Correct 109 ms 1400 KB correct
41 Correct 173 ms 1536 KB correct
42 Correct 162 ms 1664 KB correct
43 Correct 84 ms 1276 KB correct
44 Correct 69 ms 896 KB correct
45 Correct 82 ms 896 KB correct
46 Correct 62 ms 768 KB correct
47 Correct 27 ms 512 KB correct
48 Correct 2 ms 384 KB correct
49 Correct 8 ms 384 KB correct
50 Correct 26 ms 512 KB correct
51 Correct 80 ms 896 KB correct
52 Correct 70 ms 896 KB correct
53 Correct 62 ms 768 KB correct
54 Correct 87 ms 1152 KB correct
55 Correct 81 ms 1024 KB correct
56 Correct 82 ms 1024 KB correct
57 Correct 81 ms 1024 KB correct
58 Correct 1 ms 256 KB correct
59 Correct 0 ms 256 KB correct
60 Incorrect 136 ms 4320 KB WA in grader: NO
61 Halted 0 ms 0 KB -