P3647 题解

Overview

很好的题，但是难度较大。

模拟小数据！——【数据删除】

Description

给定一颗树，有边权，已知这棵树是由这两个操作得到的：

• Append(u, w)：在 $u$ 和 $w$ 之间连一条红边，注意这里的 $w$ 必须是新点。
• Insert(u, v, w)：在 $u$ 和 $w$，$v$ 和 $w$ 之间各连一条蓝边，注意这里的 $w$ 必须是新点。

问蓝线的长度最大能到多少。

Solution

我们可以尝试将所有的 Insert 所产生的蓝边对都提取出来。
它们只可能有两种形式：son - u - father 和 son1 - u - son2。

Lemma

引理：所有的蓝边都可以在某一个根上表现出形如 son - u - father 的形式。

Proof

当树上没有形如 son1 - u - son2 的蓝边时，显然成立；

当树上恰好有一个形如 son1 - u - son2 的蓝边时，可以将 son1 和 son2 其中之一作为根，解决问题；

当树上有大于一个形如 son1 - u - son2 的蓝边时，可以证明不存在这样的边。
如图，当存在形如 1 的情况时，son1 和 son2 构成了单独的连通块，因为如果不是，那么 son1 和 son2 一定会是父子关系，矛盾；
当存在多个这样的连通块时，如图 2，建树时节点一定会组成单一的连通块，因为 $u$ 总是存在，所以不成立。

Main

有了引理，就可以树形 dp 了。

枚举树根，对每个根 DP。设 $d_{u,0/1}$ 为 $u$ 为根，$u$ 是否为蓝边终点的子树最大边权和。

先看 $d_{u,0}$，因为没有边上的限制，所以可以任意取，对于是中点的情况，可以再加上边权 $w(u,v)$，即 $\max (d_{v,1}+w(u,v),d_{v,0})$。
再看 $d_{u,1}$，一定有一个 $d_{v,0}+w(u,v)$，其它都是 $\max (d_{v,1}+w(u,v),d_{v,0})$，所以要加上 $\max {\Delta }_{\text{sum}}$。

所以关于 $d$ 的状态转移方程可以这样写：

d u , 0 = ∑ v ∈ son ( u ) max ⁡ ( d v , 1 + w ( u , v ) , d v , 0 ) d u , 1 = d u , 0 + max ⁡ v ∈ son ( u ) { d v , 0 + w ( u , v ) − max ⁡ ( d v , 1 + w ( u , v ) , d v , 0 ) } d_{u,0} = \sum_{v\in \text{son}(u)}\max(d_{v,1}+w(u,v),d_{v,0})\\d_{u,1} = d_{u,0}+\max_{v\in \text{son}(u)}\{d_{v,0} + w(u,v) - \max(d_{v,1} + w(u,v), d_{v,0})\} du,0​=v∈son(u)∑​max(dv,1​+w(u,v),dv,0​)du,1​=du,0​+v∈son(u)max​{dv,0​+w(u,v)−max(dv,1​+w(u,v),dv,0​)}

这样，就可以枚举根得到 $O(n^2)$ 的复杂度，$15\text{pts}$。

接下来考虑换根 DP。

一张图解释接下来两个 DP 数组的含义。

这里的 $g$ 并不描述这个子树，而是以 $u$ 为根的整棵树。

根据 $f$ 的转移方程，我们照样也可以推出 $g$ 和 $k$ 的转移方程，留给读者思考。

注意到方程里仍有大量之前可以利用的内容，所以需要维护最大值和次大值。

Code

#include <bits/stdc++.h>

using namespace std;

int dp[200001][2], dp1[200001][2], dp2[200001][2], mx[200001], mx2[200001];

vector<pair<int, int> > gv[200001];

inline void add_edge(int u, int v, int w){
	gv[u].push_back(make_pair(v, w));
	gv[v].push_back(make_pair(u, w));
}

void dfs(int u, int fa){
	vector<int> vec;
	vec.push_back(INT_MIN), vec.push_back(INT_MIN);
	for(auto v : gv[u]){
		if(v.first == fa) continue;
		dfs(v.first, u);
		dp[u][0] += max(dp[v.first][0], dp[v.first][1] + v.second);
		vec.push_back(dp[v.first][0] + v.second - max(dp[v.first][0], dp[v.first][1] + v.second));
	}
	sort(vec.begin(), vec.end(), greater<int>());
	mx[u] = vec[0], mx2[u] = vec[1];
	dp[u][1] = dp[u][0] + mx[u];
}


void dfs1(int u, int fa, int lst){
	for(auto v : gv[u]){
		if(v.first == fa) continue;
		int tmp = dp[v.first][0] + v.second - max(dp[v.first][0], dp[v.first][1] + v.second);
		dp2[u][0] = dp1[u][0] - max(dp[v.first][0], dp[v.first][1] + v.second);
		dp2[u][1] = dp2[u][0] + (mx[u] == tmp ? mx2[u] : mx[u]);
		if(fa + 1) dp2[u][1] = max(dp2[u][1], dp2[u][0] + dp2[fa][0] + lst - max(dp2[fa][0], dp2[fa][1] + lst));
		dp1[v.first][0] = dp[v.first][0] + max(dp2[u][0], dp2[u][1] + v.second);
//		dp1[v.first][1] = dp1[v.first][0] + max(mx[v.first], dp2[u][0] + v.second - max(dp2[u][0], dp2[u][1] + v.second));
		dfs1(v.first, u, v.second);
	}
}

void init_vars(){
	// type your initiating code...
}

void solve(int testcase, ...){
	init_vars();
	int n; cin >> n;
	for(int i = 0; i < n - 1; i++){
		int u, v, w; cin >> u >> v >> w;
		add_edge(u, v, w);
	}
	dfs(1, -1); dp1[1][0] = dp[1][0];
	dfs1(1, -1, 0);
	int ans = 0;
	for(int i = 1; i <= n; i++){
		//cout << mx[i] << " " << mx2[i] << endl;
		ans = max(ans, dp1[i][0]);
	}
	cout << ans << endl;
}

signed main(){
#ifdef files
	freopen(".in", "r", stdin);
	freopen(".out", "w", stdout);
#endif
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	solve(1);
#ifdef files
	fclose(stdin); fclose(stdout);
#endif
	return 0;
}

/*
 *  things to check
 *  1.  int overflow or long long memory need
 *  2.  recursion/array/binary search/dp/loop bounds
 *  3.  precision
 *  4.  special cases(n=1,bounds)
 *  5.  delete debug statements
 *  6.  initialize(especially multi-tests)
 *  7.  = or == , n or m ,++ or -- , i or j , > or >= , < or <=
 *  8.  keep it simple and stupid
 *  9.  do not delete, use // instead
 *  10. operator priority
 *  11. is there anything extra to output?
 *  12. THINK TWICE CODE ONCE, THINK ONCE DEBUG FOREVER
 *  13. submit ONCE, AC once. submit twice, WA forever
 *  14. calm down and you'll get good rank
 *  15. even a bit wrong scores zero
 *  16. ...
 **/

 /*
 *  something to think about
 *  1. greedy? dp? searching? dp with matrix/ segment tree? binary search? ...?
 *  2. If it is difficult, why not the opposite?
 **/

/*
   ##########   ############   #####         #####
 ####                 #####      ####       ####
####                 #####        ####     ####
####             ##########        ####   ####
####               #####              #####
####              #####               #####
 ####            #####                #####
   ###########  #############         #####
*/