CodeForces 618 D Hamiltonian Spanning Tree（树形DP）

题意：给出一个完全图，每条边的权值为y，现在从中选出一棵生成树，将这棵树上的所有边的权值改为x，现在问从任意一个结点出发，遍历所有节点且每个结点只经过一次的最短路长度是多少。

思路：首先很明显分为x<=y和x>y两种情况。

当x<=y时，很明显我们要尽量用这颗生成树上的结点，也就是说在这棵树上选取尽可能多的边，使所有结点的度数不超过2.

这一步可以用树形dp来做，每个结点u有三个状态：

dp[u][0]表示结点u向儿子连0条边后子树u所能选取的最大的边的数量

dp[u][1]表示结点u向儿子连1条边后子树u所能选取的最大的边的数量

dp[u][2]表示结点u向儿子连2条边后子树u所能选取的最大的边的数量

那么状态转移方程为（cur为当前结点，u为cur的某个儿子节点）

int t1 = max(dp[u][0], dp[u][1]);
int t2 = max(t1, dp[u][2]);
int t3 = max(t1, t2);
dp[cur][2] = max(dp[cur][2]+t3, dp[cur][1]+t1+1);
dp[cur][1] = max(dp[cur][1]+t3, dp[cur][0]+t1+1);
dp[cur][0] += t3;

要注意三个状态的更新顺序。

当x>y时，要尽可能多的用生成树之外的边，可以yy发现，只有当生成树为星形时才会用到生成树上的一条边，否则可以不用。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<ctime>
#define eps 1e-6
#define LL long long
#define pii pair<int, int>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

const int MAXN = 300000;
//const int INF = 0x3f3f3f3f;
int n, x, y;
vector<int> G[MAXN];
int dp[MAXN][3];
void dfs(int cur, int fa) {
	for(int i = 0; i < G[cur].size(); i++) {
		int u = G[cur][i];
		if(u == fa) continue;
		dfs(u, cur);
		int t1 = max(dp[u][0], dp[u][1]);
		int t2 = max(t1, dp[u][2]);
		int t3 = max(t1, t2);
		dp[cur][2] = max(dp[cur][2]+t3, dp[cur][1]+t1+1);
		dp[cur][1] = max(dp[cur][1]+t3, dp[cur][0]+t1+1);
		dp[cur][0] += t3;
	}
}
int main() {
    //freopen("input.txt", "r", stdin);
	cin >> n >> x >> y;
	for(int i = 1; i < n; i++) {
		int u, v;
		scanf("%d%d", &u, &v);
		G[u].push_back(v);
		G[v].push_back(u);
	}
	dfs(1, 0);
	LL ans;
	if(x<=y) {
		int tmp = max(dp[1][0], max(dp[1][1], dp[1][2]));
		ans = (LL)x*tmp+(LL)(n-1-tmp)*y;
	}
	else {
		int shit = 0;
		for(int i = 1; i <=n; i++) 
			if(G[i].size() == n-1) shit = 1;
		ans = (LL)(n-1-shit)*y + (LL)shit*x;
	}
	cout << ans;
    return 0;
}