제출 #843253

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
843253		radoslav11	가장 긴 여행 (IOI23_longesttrip)	C++17	15 / 100	14 ms	848 KiB

longesttrip

#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <random>
#include <utility>
#include <vector>
#include "longesttrip.h"

using namespace std;

bool safe_are_connected(vector<int> S_left, vector<int> S_right) {
	if(S_left.size() == 0 || S_right.size() == 0) return false;
	return are_connected(S_left, S_right);
}

vector<vector<int>> create_adj(
	int N, vector<int> nodes, vector<pair<int, int>> edges
) {
	vector<vector<int>> adj(N);
	vector<bool> in_nodes(N, false);
	for(auto n: nodes) in_nodes[n] = true;

	for(auto e: edges) {
		if(!in_nodes[e.first] || !in_nodes[e.second]) continue;
		adj[e.first].push_back(e.second);
		adj[e.second].push_back(e.first);
	}
	return adj;
}

void prune_tree(
	int l1, int l2, int l3, vector<int> &leaves, vector<int> &par,
	vector<int> &deg
) {
	leaves.push_back(l3);

	int u = l1, v = l2;
	while(deg[u] == 1) {
		int pu = par[u];
		par[u] = v;
		deg[v]++;
		deg[pu]--;

		v = u;
		u = pu;

		if(par[u] == -1) break;
	}

	leaves.push_back(v);
}

vector<int> solve_tree(int N, vector<int> nodes, vector<vector<int>> adj) {
	// We assume that the tree is connected here
	int root = nodes[0];
	vector<int> deg(N, 0);
	for(auto node: nodes) deg[node] = adj[node].size();

	for(auto node: nodes) {
		if(deg[node] >= 3) {
			root = node;
			break;
		}
	}

	vector<int> par(nodes.size(), 0);
	vector<int> leaves;
	function<void(int, int)> dfs = [&](int node, int parent) {
		par[node] = parent;
		bool is_leaf = true;
		for(auto child: adj[node]) {
			if(child == parent) continue;
			dfs(child, node);
			is_leaf = false;
		}

		if(is_leaf) leaves.push_back(node);
	};

	dfs(root, -1);

	mt19937 mt(42);
	while(leaves.size() >= 3) {
		shuffle(leaves.begin(), leaves.end(), mt);
		int l1 = leaves.back();
		leaves.pop_back();
		int l2 = leaves.back();
		leaves.pop_back();
		int l3 = leaves.back();
		leaves.pop_back();

		if(are_connected({l1}, {l2})) {
			prune_tree(l1, l2, l3, leaves, par, deg);
		} else if(are_connected({l1}, {l3})) {
			prune_tree(l1, l3, l2, leaves, par, deg);
		} else {
			// Delta >= 1, means that l2 and l3 are connected
			prune_tree(l2, l3, l1, leaves, par, deg);
		}
	}

	// It's a path
	vector<int> path;
	vector<bool> used(N, false);

	int u = leaves[0];
	while(u != -1) {
		path.push_back(u);
		used[u] = true;
		u = par[u];
	}

	if(leaves.size() == 2) {
		u = leaves[1];
		vector<int> rev_path;
		while(!used[u]) {
			rev_path.push_back(u);
			u = par[u];
		}

		reverse(rev_path.begin(), rev_path.end());
		path.insert(path.end(), rev_path.begin(), rev_path.end());
	}

	return path;
}

pair<int, int> find_one_edge(
	vector<int> S_left, vector<int> S_right, mt19937 &mt
) {
	// assert(S_left.size() >= 1 && S_right.size() >= 1);

	if(S_left.size() == 1 && S_right.size() == 1) {
		return {S_left[0], S_right[0]};
	}

	// shuffle(S_left.begin(), S_left.end(), mt);
	// shuffle(S_right.begin(), S_right.end(), mt);

	int mid_left = S_left.size() / 2;
	int mid_right = S_right.size() / 2;

	vector<int> left_left(S_left.begin(), S_left.begin() + mid_left);
	vector<int> left_right(S_left.begin() + mid_left, S_left.end());
	vector<int> right_left(S_right.begin(), S_right.begin() + mid_right);
	vector<int> right_right(S_right.begin() + mid_right, S_right.end());

	if(safe_are_connected(left_left, right_left)) {
		return find_one_edge(left_left, right_left, mt);
	} else if(safe_are_connected(left_left, right_right)) {
		return find_one_edge(left_left, right_right, mt);
	} else if(safe_are_connected(left_right, right_left)) {
		return find_one_edge(left_right, right_left, mt);
	} else {
		return find_one_edge(left_right, right_right, mt);
	}
}

vector<int> longest_trip(int N, int D) {
	// assert(D >= 1);

	vector<int> comps[2];
	vector<pair<int, int>> edges;

	vector<int> order(N);
	iota(order.begin(), order.end(), 0);

	mt19937 mt(42);
	shuffle(order.begin(), order.end(), mt);

	comps[0].push_back(order[0]);

	int other = 1;
	while(other < N && are_connected({order[0]}, {order[other]})) {
		comps[0].push_back(order[other]);
		edges.push_back({order[0], order[other]});
		other++;
	}

	if(other == N) {
		vector<int> all_nodes(N);
		iota(all_nodes.begin(), all_nodes.end(), 0);
		auto adj = create_adj(N, all_nodes, edges);
		// cerr << "Solving tree" << endl;
		return solve_tree(N, all_nodes, adj);
	} else {
		// Maybe we have two components
		comps[1].push_back(order[other]);

		// cerr << "Other: ";
		// cerr << order[other] << endl;

		for(int i = other + 1; i < N; i++) {
			if(are_connected({order[0]}, {order[i]})) {
				comps[0].push_back(order[i]);
				edges.push_back({order[0], order[i]});
			} else {
				comps[1].push_back(order[i]);
				edges.push_back({order[other], order[i]});
			}
		}

		// cerr << "Comps:" << endl;
		// for(int i = 0; i < 2; i++) {
		// 	 for(int j = 0; j < comps[i].size(); j++) {
		// 		cerr << comps[i][j] << " ";
		// 	}
		// 	cerr << endl;
		// }

		// Check if this is one component
		if(are_connected(comps[0], comps[1])) {
			edges.push_back(find_one_edge(comps[0], comps[1], mt));
			vector<int> all_nodes(N);
			iota(all_nodes.begin(), all_nodes.end(), 0);
			auto adj = create_adj(N, all_nodes, edges);
			return solve_tree(N, all_nodes, adj);
		}

		// Two disjoint paths, so just get the longer one
		if(comps[0].size() < comps[1].size()) swap(comps[0], comps[1]);

		auto adj = create_adj(N, comps[0], edges);
		return solve_tree(N, comps[0], adj);
	}
}

• Subtask 0: 0 / 0
• Subtask 1: 5 / 5
• Subtask 2: 10 / 10
• Subtask 3: 0 / 25
• Subtask 4: 0 / 60