[codeforces538E]Demiurges Play Again

Posted 2020-08-29 xjr_01

[codeforces538E]Demiurges Play Again

试题描述

Demiurges Shambambukli and Mazukta love to watch the games of ordinary people. Today, they noticed two men who play the following game.

There is a rooted tree on n nodes, m of which are leaves (a leaf is a nodes that does not have any children), edges of the tree are directed from parent to children. In the leaves of the tree integers from 1 to m are placed in such a way that each number appears exactly in one leaf.

Initially, the root of the tree contains a piece. Two players move this piece in turns, during a move a player moves the piece from its current nodes to one of its children; if the player can not make a move, the game ends immediately. The result of the game is the number placed in the leaf where a piece has completed its movement. The player who makes the first move tries to maximize the result of the game and the second player, on the contrary, tries to minimize the result. We can assume that both players move optimally well.

Demiurges are omnipotent, so before the game they can arbitrarily rearrange the numbers placed in the leaves. Shambambukli wants to rearrange numbers so that the result of the game when both players play optimally well is as large as possible, and Mazukta wants the result to be as small as possible. What will be the outcome of the game, if the numbers are rearranged by Shambambukli, and what will it be if the numbers are rearranged by Mazukta? Of course, the Demiurges choose the best possible option of arranging numbers.

输入

The first line contains a single integer n — the number of nodes in the tree (1 ≤ n ≤ 2·10⁵).

Each of the next n - 1 lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n) — the ends of the edge of the tree; the edge leads from node u_i to node v_i. It is guaranteed that the described graph is a rooted tree, and the root is the node 1.

输出

Print two space-separated integers — the maximum possible and the minimum possible result of the game.

输入示例

6
1 2
1 3
3 4
1 5
5 6

输出示例

3 3

数据规模及约定

见“输入”

题解

树形 dp。设 mn(u, 0) 表示对于以节点 u 为根的子树中所有叶子从 1 开始编号，当前轮到后手（即希望最终答案最小的人）走所能得到的最小编号；mn(u, 1) 表示轮到先手走所能得到的最小编号。那么显然，因为后手一定是选择下一步最小的儿子走；，我们要让先手选到最大值最小，可以把每个子树 v 中小于等于 mn(v, 0) 的编号拿出来密密地排列，大于 mn(v, 0) 的部分统统扔到后面以免它们占位置。

对于求最大值的情况，做法类似。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <set>
using namespace std;

const int BufferSize = 1 << 16;
char buffer[BufferSize], *Head, *Tail;
inline char Getchar() {
	if(Head == Tail) {
		int l = fread(buffer, 1, BufferSize, stdin);
		Tail = (Head = buffer) + l;
	}
	return *Head++;
}
int read() {
	int x = 0, f = 1; char c = Getchar();
	while(!isdigit(c)){ if(c == \'-\') f = -1; c = Getchar(); }
	while(isdigit(c)){ x = x * 10 + c - \'0\'; c = Getchar(); }
	return x * f;
}

#define maxn 200010
#define maxm 400010
#define oo 2147483647

int n, m, head[maxn], next[maxm], to[maxm];
void AddEdge(int a, int b) {
	to[++m] = b; next[m] = head[a]; head[a] = m;
	swap(a, b);
	to[++m] = b; next[m] = head[a]; head[a] = m;
	return ;
}
int cntl, mn[2][maxn], mx[2][maxn];
void calc(int u, int fa) {
	bool has = 0;
	for(int e = head[u]; e; e = next[e]) if(to[e] != fa)
		has = 1, calc(to[e], u);
	if(!has) cntl++, mn[0][u] = mn[1][u] = mx[0][u] = mx[1][u] = 1;
	return ;
}

void dp(int u, int fa) {
	if(mn[1][u]) return ;
	mn[1][u] = 0; mn[0][u] = oo;
	mx[1][u] = oo; mx[0][u] = 0;
	for(int e = head[u]; e; e = next[e]) if(to[e] != fa) {
		dp(to[e], u);
		mn[1][u] += mn[0][to[e]],
		mn[0][u] = min(mn[0][u], mn[1][to[e]]),
		mx[1][u] = min(mx[1][u], mx[0][to[e]]),
		mx[0][u] += mx[1][to[e]];
	}
//	printf("%d: %d %d %d %d\\n", u, mn[1][u], mn[0][u], mx[1][u], mx[0][u]);
	return ;
}

int main() {
	n = read();
	for(int i = 1; i < n; i++) {
		int a = read(), b = read();
		AddEdge(a, b);
	}
	
	calc(1, 0);
	dp(1, 0);
	
	printf("%d %d\\n", cntl + 1 - mx[1][1], mn[1][1]);
	
	return 0;
}