結果

問題 No.529 帰省ラッシュ
ユーザー pekempeypekempey
提出日時 2017-06-09 23:17:39
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 4,395 bytes
コンパイル時間 1,337 ms
コンパイル使用メモリ 99,840 KB
実行使用メモリ 34,924 KB
最終ジャッジ日時 2024-09-22 18:39:24
合計ジャッジ時間 6,895 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 WA -
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 WA -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <functional>

struct HLD {
	using Tree = std::vector<std::vector<int>>;
	const Tree &tree;

	std::vector<int> parent;
	std::vector<int> head;
	std::vector<int> vid;

	HLD(const Tree &tree) : tree(tree) {
		const int n = tree.size();
		const int root = 0;
		std::stack<std::pair<int, int>> stack;
		stack.emplace(root, 0);

		parent.assign(n, -1);
		head.assign(n, -1);
		vid.assign(n, -1);

		std::vector<int> heavy(n, -1);
		std::vector<int> size(n, 1);
		while (!stack.empty()) {
			const int u = stack.top().first;
			const int i = stack.top().second;
			if (i < tree[u].size()) {
				stack.top().second++;
				const int v = tree[u][i];
				if (v != parent[u]) {
					parent[v] = u;
					stack.emplace(v, 0);
				}
			} else {
				stack.pop();
				int max = 0;
				for (int v : tree[u]) {
					if (v != parent[u]) {
						size[u] += size[v];
						if (max < size[v]) {
							max = size[v];
							heavy[u] = v;
						}
					}
				}
			}
		}

		std::queue<int> queue;
		queue.push(0);
		int now = 0;
		while (!queue.empty()) {
			const int h = queue.front();
			queue.pop();
			for (int i = h; i != -1; i = heavy[i]) {
				head[i] = h;
				vid[i] = now++;
				for (int j : tree[i]) {
					if (j != parent[i] && j != heavy[i]) {
						queue.push(j);
					}
				}
			}
		}
	}

	template<typename T>
	void foreach(int u, int v, T func) {
		while (true) {
			if (vid[u] > vid[v]) {
				std::swap(u, v);
			}
			if (head[u] != head[v]) {
				func(vid[head[v]], vid[v]);
				v = parent[head[v]];
			} else {
				func(vid[u], vid[v]);
				break;
			}
		}
	}

	int lca(int u, int v) {
		while (true) {
			if (vid[u] > vid[v]) {
				std::swap(u, v);
			}
			if (head[u] != head[v]) {
				v = parent[head[v]];
			} else {
				return u;
			}
		}
	}
};

std::vector<int> TECC(const std::vector<std::vector<int>> &g) {
	const int n = g.size();
	std::vector<int> ord(n, -1);
	std::vector<int> low(n);
	std::vector<int> cid(n);
	std::vector<int> s;
	int k = 0;
	int c = 0;
	std::function<void(int, int)> dfs = [&](int u, int p) {
		low[u] = ord[u] = k++;
		s.push_back(u);
		for (int v : g[u]) {
			if (ord[v] == -1) {
				dfs(v, u);
				low[u] = std::min(low[u], low[v]);
			} else if (v != p) {
				low[u] = std::min(low[u], ord[v]);
			}
		}
		if (p == -1 || ord[p] < low[u]) {
			while (true) {
				int v = s.back();
				s.pop_back();
				cid[v] = c;
				if (v == u) {
					break;
				}
			}
			c++;
		}
	};
	for (int i = 0; i < n; i++) {
		if (ord[i] == -1) {
			dfs(i, -1);
		}
	}
	return cid;
}

int main() {
	int n, m, q;
	std::cin >> n >> m >> q;

	std::vector<std::vector<int>> g(n);
	for (int i = 0; i < m; i++) {
		int u, v;
		scanf("%d %d", &u, &v);
		u--;
		v--;
		g[u].push_back(v);
		g[v].push_back(u);
	}

	auto tecc = TECC(g);

	int nn = *max_element(tecc.begin(), tecc.end()) + 1;
	std::vector<std::vector<int>> gg(nn);
	for (int i = 0; i < n; i++) {
		for (int j : g[i]) {
			if (tecc[i] != tecc[j]) {
				gg[tecc[i]].push_back(tecc[j]);
			}
		}
	}

	HLD hld(gg);

	int N = 1;
	while (N < nn) {
		N *= 2;
	}
	std::vector<std::pair<int, int>> rmq(N * 2, std::make_pair(-1, 0));

	auto setval = [&](int k, int v, int index) {
		rmq[k + N] = { v, index };
		k += N;
		while (k > 1) {
			k /= 2;
			rmq[k] = std::max(rmq[k * 2], rmq[k * 2 + 1]);
		}
	};

	auto getval = [&](int l, int r) {
		l += N;
		r += N;
		std::pair<int, int> ret(-1, 0);
		while (l < r) {
			if (l & 1) {
				ret = std::max(ret, rmq[l++]);
			}
			if (r & 1) {
				ret = std::max(ret, rmq[--r]);
			}
			l /= 2;
			r /= 2;
		}
		return ret;
	};

	std::vector<std::priority_queue<int>> qs(nn);

	while (q--) {
		int t;
		scanf("%d", &t);
		if (t == 1) {
			int u, w;
			scanf("%d %d", &u, &w);
			u = tecc[u - 1];
			if (qs[u].empty() || qs[u].top() < w) {
				setval(hld.vid[u], w, u);
			}
			qs[u].push(w);
		} else {
			int s, t;
			scanf("%d %d", &s, &t);
			s = tecc[s - 1];
			t = tecc[t - 1];
			std::pair<int, int> ans(-1, 0);
			hld.foreach(s, t, [&](int l, int r) {
				ans = std::max(ans, getval(l, r + 1));
			});
			if (ans.first != -1) {
				qs[ans.second].pop();
				if (qs[ans.second].empty()) {
					setval(hld.vid[ans.second], -1, ans.second);
				} else {
					setval(hld.vid[ans.second], qs[ans.second].top(), ans.second);
				}
			}
			printf("ans:%d\n", ans.first);
		}
	}
}
0