#597776 (C++17) No.1436 Rgaph

提出ソース
結果

問題	No.1436 Rgaph
ユーザー	nok0
提出日時	2020-12-27 13:39:09
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	36 ms / 2,000 ms
コード長	18,406 bytes
コンパイル時間	3,606 ms
コンパイル使用メモリ	259,720 KB
実行使用メモリ	6,820 KB
最終ジャッジ日時	2024-11-21 07:25:36
合計ジャッジ時間	5,884 ms
ジャッジサーバーID （参考情報）	judge2 / judge3
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 6,816 KB
testcase_01	AC	2 ms 6,820 KB
testcase_02	AC	2 ms 6,820 KB
testcase_03	AC	2 ms 6,816 KB
testcase_04	AC	2 ms 6,820 KB
testcase_05	AC	2 ms 6,816 KB
testcase_06	AC	16 ms 6,816 KB
testcase_07	AC	2 ms 6,816 KB
testcase_08	AC	2 ms 6,816 KB
testcase_09	AC	2 ms 6,820 KB
testcase_10	AC	18 ms 6,816 KB
testcase_11	AC	3 ms 6,816 KB
testcase_12	AC	3 ms 6,820 KB
testcase_13	AC	2 ms 6,820 KB
testcase_14	AC	3 ms 6,816 KB
testcase_15	AC	2 ms 6,820 KB
testcase_16	AC	2 ms 6,816 KB
testcase_17	AC	3 ms 6,820 KB
testcase_18	AC	3 ms 6,816 KB
testcase_19	AC	3 ms 6,820 KB
testcase_20	AC	6 ms 6,816 KB
testcase_21	AC	5 ms 6,820 KB
testcase_22	AC	19 ms 6,820 KB
testcase_23	AC	13 ms 6,820 KB
testcase_24	AC	22 ms 6,816 KB
testcase_25	AC	34 ms 6,816 KB
testcase_26	AC	36 ms 6,816 KB
testcase_27	AC	36 ms 6,816 KB
testcase_28	AC	2 ms 6,816 KB
testcase_29	AC	17 ms 6,820 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
/**
 *	author: nok0
 *	created: 2020.11.07 23:37:48
**/
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
#pragma region Macros
#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for(int i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T>>;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define VEC(type, name, size) \
	V<type> name(size);       \
	INPUT(name)
#define VVEC(type, name, h, w)    \
	VV<type> name(h, V<type>(w)); \
	INPUT(name)
#define INT(...)     \
	int __VA_ARGS__; \
	INPUT(__VA_ARGS__)
#define LL(...)     \
	ll __VA_ARGS__; \
	INPUT(__VA_ARGS__)
#define STR(...)        \
	string __VA_ARGS__; \
	INPUT(__VA_ARGS__)
#define CHAR(...)     \
	char __VA_ARGS__; \
	INPUT(__VA_ARGS__)
#define DOUBLE(...)     \
	DOUBLE __VA_ARGS__; \
	INPUT(__VA_ARGS__)
#define LD(...)     \
	LD __VA_ARGS__; \
	INPUT(__VA_ARGS__)
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T>
void scan(V<T> &);
template <class T, class L>
void scan(pair<T, L> &);
template <class T>
void scan(V<T> &a) {
	for(auto &i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L> &p) {
	scan(p.first);
	scan(p.second);
}
template <class T>
void scan(T &a) { cin >> a; }
void INPUT() {}
template <class Head, class... Tail>
void INPUT(Head &head, Tail &... tail) {
	scan(head);
	INPUT(tail...);
}
template <class T>
inline void print(T x) { cout << x << '\n'; }
template <class T>
inline void dump(T x) {
	cout << x << '\n';
	exit(0);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
	is >> p.first >> p.second;
	return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
	os << p.first << " " << p.second;
	return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
	for(T &in : v) is >> in;
	return is;
}
template <class T>
ostream &operator<<(ostream &os, const V<T> &v) {
	REP(i, SZ(v)) {
		if(i) os << " ";
		os << v[i];
	}
	return os;
}
//debug
template <typename T>
void view(const V<T> &v) {
	cerr << "{ ";
	for(const auto &e : v) {
		cerr << e << ", ";
	}
	cerr << "\b\b }";
}
template <typename T>
void view(const VV<T> &vv) {
	cerr << "{\n";
	for(const auto &v : vv) {
		cerr << "\t";
		view(v);
		cerr << "\n";
	}
	cerr << "}";
}
template <typename T, typename U>
void view(const V<pair<T, U>> &v) {
	cerr << "{\n";
	for(const auto &c : v) cerr << "\t(" << c.first << ", " << c.second << ")\n";
	cerr << "}";
}
template <typename T, typename U>
void view(const map<T, U> &m) {
	cerr << "{\n";
	for(auto &t : m) cerr << "\t[" << t.first << "] : " << t.second << "\n";
	cerr << "}";
}
template <typename T, typename U>
void view(const pair<T, U> &p) { cerr << "(" << p.first << ", " << p.second << ")"; }
template <typename T>
void view(const set<T> &s) {
	cerr << "{ ";
	for(auto &t : s) {
		view(t);
		cerr << ", ";
	}
	cerr << "\b\b }";
}
template <typename T>
void view(T e) { cerr << e; }
#ifdef LOCAL
void debug_out() {}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
	view(H);
	cerr << ", ";
	debug_out(T...);
}
#define debug(...)                                           \
	do {                                                     \
		cerr << __LINE__ << " [" << #__VA_ARGS__ << "] : ["; \
		debug_out(__VA_ARGS__);                              \
		cerr << "\b\b]\n";                                   \
	} while(0)
#else
#define debug(...) (void(0))
#endif
template <class T>
V<T> press(V<T> &x) {
	V<T> res = x;
	sort(all(res));
	res.erase(unique(all(res)), res.end());
	REP(i, SZ(x)) {
		x[i] = lower_bound(all(res), x[i]) - res.begin();
	}
	return res;
}
template <class T>
inline bool chmin(T &a, T b) {
	if(a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T>
inline bool chmax(T &a, T b) {
	if(a < b) {
		a = b;
		return true;
	}
	return false;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
	if(b) {
		cout << -1 << '\n';
		exit(0);
	}
}
template <class T>
inline void fin(bool b = true, T e = 0) {
	if(b) {
		cout << e << '\n';
		exit(0);
	}
}
template <class T>
T divup(T x, T y) { return (x + (y - 1)) / y; }
template <typename T>
T pow(T a, long long n, T e = 1) {
	T ret = e;
	while(n) {
		if(n & 1) ret *= a;
		a *= a;
		n >>= 1;
	}
	return ret;
}
struct iofast {
	iofast() {
		ios::sync_with_stdio(false);
		cin.tie(nullptr);
		cout << fixed << setprecision(15);
	}
} iofast_;
const int inf = 1e9;
const ll INF = 1e18;
#pragma endregion

struct Edge {
	int to;
	long long cost;
	Edge() = default;
	Edge(int to_, long long cost_)
	  : to(to_), cost(cost_) {}
	bool operator<(const Edge &a) const {
		return cost < a.cost;
	}
	bool operator>(const Edge &a) const {
		return cost > a.cost;
	}
	friend std::ostream &operator<<(std::ostream &s, Edge &a) {
		s << "to:" << a.to << " cost:" << a.cost;
		return s;
	}
};

struct Graph : private std::vector<std::vector<Edge>> {
	using std::vector<std::vector<Edge>>::vector;
	using std::vector<std::vector<Edge>>::operator[];
	using std::vector<std::vector<Edge>>::operator=;
	using std::vector<std::vector<Edge>>::size;
	using std::vector<std::vector<Edge>>::resize;
	using std::vector<std::vector<Edge>>::clear;
	using std::vector<std::vector<Edge>>::push_back;
	using std::vector<std::vector<Edge>>::emplace_back;
	using std::vector<std::vector<Edge>>::begin;
	using std::vector<std::vector<Edge>>::end;

private:
	const long long INF = 1e18;

	bool isweight = true, lcainit_done = false;
	std::vector<std::vector<int>> parent;
	std::vector<int> lcadist;

	template <class T>
	inline bool chmax(T &a, T b) {
		if(a < b) {
			a = b;
			return true;
		}
		return false;
	}

	template <class T>
	inline bool chmin(T &a, T b) {
		if(a > b) {
			a = b;
			return true;
		}
		return false;
	}

	vector<pii> edges;

public:
	void read(int e = -1, bool weight = 0, bool directed = false, int idx = 1) {
		if(e == -1) e = size() - 1;
		if(!weight) isweight = false;
		while(e--) {
			int u, v;
			long long cost = 1;
			std::cin >> u >> v;
			if(weight) std::cin >> cost;
			u -= idx, v -= idx;
			edges.eb(u, v);
			(*this)[u].emplace_back(v, cost);
			if(!directed) (*this)[v].emplace_back(u, cost);
		}
	}

	void add(int u, int v, int cost = -1, bool directed = false, int idx = 1) {
		if(cost != -1)
			isweight = true;
		else
			cost = 1;
		u -= idx, v -= idx;
		(*this)[u].emplace_back(v, cost);
		if(!directed) (*this)[v].emplace_back(u, cost);
	}

	std::vector<long long> Dijkstra(int s) {
		std::vector dist(size(), INF);
		if(isweight) {
			using pll = std::pair<long long, long long>;
			std::priority_queue<pll, std::vector<pll>, std::greater<pll>> que;
			dist[s] = 0;
			que.push(pll(0, s));
			while(!que.empty()) {
				pll p = que.top();
				que.pop();
				int v = p.second;
				if(dist[v] < p.first) continue;
				for(int i = 0; i < int((*this)[v].size()); i++) {
					Edge e = (*this)[v][i];
					if(dist[e.to] > dist[v] + e.cost) {
						dist[e.to] = dist[v] + e.cost;
						que.push(pll(dist[e.to], e.to));
					}
				}
			}
			return dist;
		} else {
			std::vector dist(size(), INF);
			std::queue<int> que;
			dist[s] = 0;
			que.push(s);
			while(!que.empty()) {
				int v = que.front();
				que.pop();
				for(auto nv : (*this)[v]) {
					if(dist[nv.to] != INF) continue;
					dist[nv.to] = dist[v] + 1;
					que.push(nv.to);
				}
			}
			return dist;
		}
	}

	std::vector<long long> BellmanFord(int s) {
		int n = size();
		std::vector res(n, INF);
		res[s] = 0;
		for(int loop = 0; loop < n - 1; loop++) {
			for(int v = 0; v < n; v++) {
				if(res[v] == INF) continue;
				for(auto &e : (*this)[v]) {
					res[e.to] = std::min(res[e.to], res[v] + e.cost);
				}
			}
		}

		std::queue<int> que;
		std::vector chk(n, 0);
		for(int v = 0; v < n; v++) {
			if(res[v] == INF) continue;
			for(auto &e : (*this)[v]) {
				if(res[e.to] > res[v] + e.cost) {
					res[e.to] = res[v] + e.cost;
					if(!chk[e.to]) {
						que.push(e.to);
						chk[e.to] = 1;
					}
				}
			}
		}
		while(!que.empty()) {
			int now = que.front();
			que.pop();
			for(auto &e : (*this)[now]) {
				if(!chk[e.to]) {
					chk[e.to] = 1;
					que.push(e.to);
				}
			}
		}
		for(int i = 0; i < n; i++)
			if(chk[i]) res[i] = -INF;
		return res;
	}

	std::vector<std::vector<long long>> WarshallFloyd() {
		int n = size();
		std::vector dist(n, std::vector(n, INF));
		for(int i = 0; i < n; i++) {
			dist[i][i] = 0;
		}
		for(int i = 0; i < n; i++) {
			for(auto e : (*this)[i]) {
				chmin(dist[i][e.to], e.cost);
			}
		}
		for(int k = 0; k < n; k++)
			for(int i = 0; i < n; i++)
				for(int j = 0; j < n; j++)
					chmin(dist[i][j], dist[i][k] + dist[k][j]);
		return dist;
	}

	int lca(int u, int v) {
		std::function<void(int, int, int)> dfs = [&](int now, int per, int d) {
			parent[0][now] = per;
			lcadist[now] = d;
			for(auto &e : (*this)[now])
				if(e.to != per) dfs(e.to, now, d + 1);
		};

		if(!lcainit_done) {
			lcainit_done = true;
			int n = size();
			int k = 1;
			while((1 << k) < n) k++;
			parent.assign(k, std::vector(n, -1));
			lcadist.assign(n, -1);
			dfs(0, -1, 0);
			for(int i = 0; i < k - 1; i++)
				for(int v = 0; v < n; v++) {
					if(parent[i][v] < 0)
						parent[i + 1][v] = -1;
					else
						parent[i + 1][v] = parent[i][parent[i][v]];
				}
		}
		if(lcadist[u] < lcadist[v]) std::swap(u, v);
		int k = parent.size();
		for(int i = 0; i < k; i++)
			if((lcadist[u] - lcadist[v]) >> i & 1) u = parent[i][u];
		if(u == v) return u;
		for(int i = k - 1; i >= 0; i--)
			if(parent[i][u] != parent[i][v])
				u = parent[i][u], v = parent[i][v];
		return parent[0][u];
	}

	int dist(int u, int v) { return lcadist[u] + lcadist[v] - 2 * lcadist[lca(u, v)]; }

	std::vector<int> tsort() {
		std::vector<int> res;
		int n = size();
		std::vector<int> used(n, 0);
		bool notDAG = false;

		std::function<void(int)> dfs = [&](int k) {
			if(notDAG) return;
			if(used[k]) {
				if(used[k] == 1)
					notDAG = true;
				return;
			}
			used[k] = 1;
			for(auto &e : (*this)[k]) dfs(e.to);
			used[k] = 2;
			res.push_back(k);
		};

		for(int i = 0; i < n; i++) dfs(i);
		if(notDAG) return std::vector<int>{};
		std::reverse(res.begin(), res.end());
		return res;
	}

	bool isDAG() { return tsort().size(); }

	std::vector<long long> height() {
		std::vector<long long> fir(size(), -1), sec(size(), -1);

		std::function<long long(int, int)> dfs = [&](int now, int par) {
			long long f = 0, s = 0;
			for(auto &e : (*this)[now]) {
				if(e.to == par) continue;
				s = std::max(s, dfs(e.to, now) + e.cost);
				if(f < s) std::swap(f, s);
			}
			sec[now] = s;
			return fir[now] = f;
		};

		std::function<void(int, int, long long, long long, long long)> solve = [&](int now, int par, long long parf, long long pars, long long parcost) {
			if(fir[now] + parcost == parf) parf = pars;
			sec[now] = std::max(sec[now], parf + parcost);
			if(fir[now] < sec[now]) std::swap(fir[now], sec[now]);
			for(auto &e : (*this)[now]) {
				if(e.to == par) continue;
				solve(e.to, now, fir[now], sec[now], e.cost);
			}
			return;
		};

		dfs(0, -1);
		solve(0, -1, -1, -1, -1);
		return fir;
	}

	//{二部グラフか、二部グラフのどちらに属するかを0か1で表した配列}
	std::pair<bool, std::vector<int>> isBiparate() {
		std::vector<int> colors(size()), ret(size());

		std::function<bool(int, int)> dfs = [&](int now, int col) {
			colors[now] = col;
			if(col == 1) ret[now] = 1;
			for(auto &e : (*this)[now]) {
				if(col == colors[e.to]) return false;
				if(colors[e.to] == 0 and !dfs(e.to, -col)) return false;
			}
			return true;
		};

		return std::pair(dfs(0, 1), ret);
	}

	//{{端点、端点},直径の大きさ}
	std::pair<std::pair<int, int>, long long> Diameter() {
		auto vec = Dijkstra(0);
		int v1 = -1, v2 = -1;
		long long dia = -1;
		for(int i = 0; i < int(size()); i++)
			if(chmax(dia, vec[i]))
				v1 = i;
		vec = Dijkstra(v1);
		dia = -1;
		for(int i = 0; i < int(size()); i++)
			if(chmax(dia, vec[i]))
				v2 = i;

		std::pair<std::pair<int, int>, long long> res = {{v1, v2}, dia};
		return res;
	}

	//最小全域木
	long long Prim() {
		long long res = 0;
		std::priority_queue<Edge, std::vector<Edge>, std::greater<Edge>> que;
		for(auto &e : (*this)[0])
			que.push(e);
		std::vector chk(size(), 0);
		chk[0] = 1;
		while(!que.empty()) {
			auto e = que.top();
			que.pop();
			if(chk[e.to]) continue;
			res += e.cost;
			chk[e.to] = 1;
			for(auto &e : (*this)[e.to]) {
				que.push(e);
			}
		}
		return res;
	}

	//重心
	std::vector<int> Centroid() {
		int n = size();
		std::vector<int> centroid, sz(n);

		std::function<void(int, int)> dfs = [&](int now, int per) {
			sz[now] = 1;
			bool is_centroid = true;
			for(auto &e : (*this)[now])
				if(e.to != per) {
					dfs(e.to, now);
					sz[now] += sz[e.to];
					if(sz[e.to] > n / 2) is_centroid = false;
				}
			if(n - sz[now] > n / 2) is_centroid = false;
			if(is_centroid) centroid.push_back(now);
		};

		return centroid;
	}

	//pair{橋(pairの配列),関節点(intの配列)}
	std::pair<std::vector<std::pair<int, int>>, std::vector<int>> lowlink() {
		int n = size(), k = 0;
		std::vector<int> used(n, 0), order(n, 0), low(n, 0), articulation;
		std::vector<std::pair<int, int>> bridge;

		std::function<int(int, int, int)> dfs = [&](int idx, int k, int par) {
			used[idx] = 1;
			order[idx] = k++;
			low[idx] = order[idx];
			bool is_articulation = false, neko = false;
			int cnt = 0;
			for(auto &e : (*this)[idx]) {
				if(e.to == par and !std::exchange(neko, true)) {
					continue;
				}
				if(!used[e.to]) {
					++cnt;
					k = dfs(e.to, k, idx);
					low[idx] = std::min(low[idx], low[e.to]);
					is_articulation |= par >= 0 and low[e.to] >= order[idx];
					if(order[idx] < low[e.to]) {
						auto p = std::minmax(idx, e.to);
						bridge.emplace_back(p.first, p.second);
					}
				} else {
					low[idx] = std::min(low[idx], order[e.to]);
				}
			}
			is_articulation |= par == -1 and cnt > 1;
			if(is_articulation) articulation.push_back(idx);
			return k;
		};

		for(int i = 0; i < n; i++)
			if(!used[i]) k = dfs(i, k, -1);
		return std::pair(bridge, articulation);
	}
	//根から葉への有向グラフ
	Graph RootToLeaf(int root = 0) {
		Graph res(size());
		std::vector chk(size(), 0);
		chk[root] = 1;
		std::function<void(int)> dfs = [&](int now) {
			for(auto &e : (*this)[now]) {
				if(chk[e.to] == 1) continue;
				chk[e.to] = 1;
				res.add(now, e.to, e.cost, 1, 0);
				dfs(e.to);
			}
		};
		dfs(root);
		return res;
	}

	//葉から根への有向グラフ
	Graph LeafToRoot(int root = 0) {
		Graph res(size());
		std::vector chk(size(), 0);
		chk[root] = 1;
		std::function<void(int)> dfs = [&](int now) {
			for(auto &e : (*this)[now]) {
				if(chk[e.to] == 1) continue;
				chk[e.to] = 1;
				res.add(e.to, now, e.cost, 1, 0);
				dfs(e.to);
			}
		};
		dfs(root);
		return res;
	}

	//辺(from,to)を返す(無向ならu->vとv->u共に入る)
	std::vector<std::pair<int, int>> getedges() {
		return edges;
	}

	//辺(from,to,cost)を返す(無向ならu->vとv->u共に入る)
	std::vector<std::tuple<int, int, long long>> getwedges() {
		std::vector<std::tuple<int, int, long long>> ret;
		for(int i = 0; i < size(); i++) {
			for(auto &e : (*this)[i]) ret.emplace_back(i, e.to, e.cost);
		}
		return ret;
	}
};

//Strongly Connected Components(強成分連結分解)(Graph Templateと併用)
struct SCC {
	const Graph &g;
	Graph ng, rg;
	V<int> compo, order, used;

	//g:元のグラフ, ret:強連結成分分解後のグラフ
	SCC(Graph &g, Graph &ret) : g(g), ng(SZ(g)), rg(SZ(g)), compo(SZ(g), -1), used(SZ(g)) {
		REP(i, SZ(g)) {
			for(auto &v : g[i]) {
				ng[i].eb(v.to, 1);
				rg[v.to].eb(i, 1);
			}
		}
		build(ret);
	}

	int operator[](int k) { return compo[k]; }

	void dfs(int now) {
		if(used[now]) return;
		used[now] = true;
		for(auto &e : ng[now]) dfs(e.to);
		order.eb(now);
	}

	void rdfs(int now, int count) {
		if(compo[now] != -1) return;
		compo[now] = count;
		for(auto &e : rg[now]) rdfs(e.to, count);
	}

	void build(Graph &ret) {
		REP(i, SZ(ng))
		dfs(i);
		reverse(all(order));
		int group = 0;
		for(auto i : order)
			if(compo[i] == -1) rdfs(i, group), group++;
		ret.resize(group);
		REP(i, SZ(g)) {
			for(auto &e : g[i]) {
				int s = compo[i], t = compo[e.to];
				if(s != t) ret[s].eb(t, 1);
			}
		}
	}
};

int main() {
	INT(n, m);
	vector res(m, 0);

	Graph G(n);
	G.read(m, 0, 1);

	Graph ret;
	SCC scc(G, ret);
	if(ret.size() > 1) dump(-1);
	if(G.isBiparate().first) dump(-1);

	V<> ver;
	int shortest = n + 1;
	REP(i, n) {
		vector dist(n, -1);
		vector prev(n, -1);
		queue<int> que;
		que.push(i);
		dist[i] = 0;
		while(SZ(que)) {
			int now = que.front();
			que.pop();
			for(auto &e : G[now]) {
				int to = e.to;
				if(dist[to] == -1) {
					dist[to] = dist[now] + 1;
					prev[to] = now;
					que.push(to);
				}
			}
		}
		REP(j, n) {
			if(j == i or dist[j] == -1) continue;
			for(auto &e : G[j]) {
				if(e.to == i) {
					vector tmp(1, i);
					int cur = j;
					while(cur != i) tmp.pb(cur), cur = prev[cur];
					if(shortest > SZ(tmp)) {
						shortest = SZ(tmp);
						ver = tmp;
					}
				}
			}
		}
	}
	reverse(all(ver));
    if(SZ(ver) == m) dump(-1);
	ver.pb(ver[0]);

	auto E = G.getedges();
	map<pii, int> encode;
	REP(i, SZ(E)) { encode[E[i]] = i; }

	debug(ver);

	int tmp = (SZ(ver) - 1) / 2 + 1;
	debug(tmp);
	V<pii> chk;

	REP(i, SZ(ver) - 1) {
		chk.eb(encode[{ver[i], ver[i + 1]}], SZ(G[ver[i]]));
	}
	sort(all(chk), [](pii a, pii b) { return a.second > b.second; });
	REP(i, tmp) { res[chk[i].first] = 1; }

	string ans = "";

	REP(i, m) { ans += (res[i] ? 'G' : 'R'); }

	dump(ans);
}
yukicoder

結果

テストケース

ソースコード
