传送门


题面翻译见洛谷传送门。


这种偏向构造的题真的不好想啊，凭什么定位在绿题……


首先考虑最少需要多少种不同的权值。

如果任意两个叶子节点之间的距离都是偶数或者奇数，那么所有边权只要赋同一个值就能满足条件。

那么如果既有偶数又有奇数呢？这我就想不到了。按题解的思路，我们都知道\(1 \bigoplus 2 \bigoplus 3= 0\)，然后有这么个赋值方法：对于到根的距离为偶数的叶子，把最下面的一条边赋值为1，其余到根的路径都赋值为2；对于到根的距离为奇数的叶子，把最下面的一条边赋值为3，其余到根的路径都赋值为2.

首先结论是，这种方法一定满足叶子节点之间的异或和为0，接下来考虑证明：

只用考虑叶子\(x,y\)分别到根的距离奇偶相同和奇偶不同的情况：

1. 奇偶相同：如果两叶子的lca是根，那么路径的总长度一定是偶数（偶+偶=偶，奇+奇=偶），又因为离叶子最近的两条边边权相同，所以边权一定是偶数个'2'+2个('1'或'3')的形式，那么异或和为0；如果两叶子的lca不是根，那么只用考虑\(x\)到\(lca\),\(lca\)到\(y\)的路径，因为奇偶相同，所以同减去一个值后奇偶也相同，那么加和一定是偶数，就也变成了lca是根的情况，因此异或和也为0.

2. 奇偶不同：如果两叶子的lca是根，那么路径的总长度一定是奇数，因此一定是奇数个'2'+1个'1'+1个'3'，因此异或和为0；如果两叶子的lca不是根，减去同一个值后也变成了lca为根的情况。

综上，这种构造方法必定满足叶子之间路径的异或和为0.


那么接下来考虑最多需要多少种不同的权值。

对于一颗子树，只要保证所有叶子节点到子树根节点路径的异或和相同即可。因为权值可以无限大，所以唯一的限制就是该节点有几个作为叶子的儿子节点，记这个值为\(cnt_i\)，那么答案就是\(n-1-\sum_{i=1}^n \max\{0, cnt_i-1\}\).

这个一遍dfs就能求出来。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<queue>
#include<assert.h>
#include<ctime>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
In ll read()
{
	ll ans = 0;
	char ch = getchar(), las = ' ';
	while(!isdigit(ch)) las = ch, ch = getchar();
	while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
	if(las == '-') ans = -ans;
	return ans;
}
In void write(ll x)
{
	if(x < 0) x = -x, putchar('-');
	if(x >= 10) write(x / 10);
	putchar(x % 10 + '0');
}
In void MYFILE()
{
#ifndef mrclr
	freopen(".in", "r", stdin);
	freopen(".out", "w", stdout);
#endif
}

int n, du[maxn];
struct Edge
{
	int nxt, to;
}e[maxn << 1];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
	e[++ecnt] = (Edge){head[x], y};
	head[x] = ecnt;
}

int dis[maxn];
In void dfs1(int now, int _f)
{
	forE(i, now, v) if(v != _f)
	{
		dis[v] = dis[now] + 1;
		dfs1(v, now);
	}
}
In int dfs2(int now, int _f)
{
	int ret = 0, cnt = 0;
	forE(i, now, v)
	{
		if(v == _f) continue;
		ret += dfs2(v, now);
		cnt += (du[v] == 1);
	}
	return ret + max(0, cnt - 1);
}

int main()
{
//	MYFILE();
	Mem(head, -1);
	n = read();
	for(int i = 1; i < n; ++i)
	{
		int x = read(), y = read();
		addEdge(x, y), addEdge(y, x);
		du[x]++, du[y]++;
	}
	int root = 0;		//选一个非叶子节点作为根 
	for(int i = 1; i <= n && !root; ++i) if(du[i] > 1) root = i;
	dfs1(root, 0);
	int cnt[2]; cnt[0] = cnt[1] = 0;
	for(int i = 1; i <= n; ++i) if(du[i] == 1) cnt[dis[i] & 1]++;
	write((cnt[0] && cnt[1]) ? 3 : 1), space;
	write(n - 1 - dfs2(root, 0)), enter;
	return 0;
}