CF671D Roads in Yusland 题解

题目链接

题目要求我们求出选出若干条路径并最小化花费，如果这是在链上，我们可以考虑直接枚举每条路径的右端点 dp，那树呢？把路径剖分整个覆盖的集合就不一定连续了，没法 dp，况且题目里给了很强的条件：路径一定是从孩子到祖先，硬转链用不上这个性质，貌似不太对。

上述思考启发我们利用树的形态设计算法，而利用节点的子树分割成子问题是一个通常的思考方向，我们从此处入手，考虑如果要覆盖一棵树需要什么条件，首先，根节点的每棵子树必须被覆盖，并且还要有一条能向外延伸的边以覆盖连接根节点和子树根节点的边。

考虑设计 dp 以维护上述条件，为了维护前者，我们可以钦定每个节点的状态所选择的解中子树全部被覆盖；而后者，由于子树内所有节点的祖先并都在固定的一条链上，我们可以添加一维确定向外延伸的长度。具体地，我们设 \(f_{u,j}\) 表示完全覆盖节点 \(u\) 的子树且向外延伸了 \(j\) 个长度的最小花费。

转移是显然的，设 \(g_u=\min f_{u,j}\)，则 \(f_{u,j}=\min \{f_{v,j}\}+\sum_{k\in son(v)} g_k -g_v\)。这个做法是 \(O(n^2)\) 的。

由于转移比较简单，我们考虑能不能用数据结构维护第二维，需要支持合并取 min 和全局加，用线段树合并就可以维护，时间和空间复杂度都是 \(O((n+m)\log n)\) 的。

但是本题空间复杂度限制比较紧，注意到线段树中有很多没有用的节点，并且不能动态调整空间。考虑换成平衡树，每个节点储存二元组 \((j,cost)\) 表示向上延伸 \(j\) 距离花费 \(cost\)，全局加可以直接打标记，合并可以直接启发式合并，全部插到里面就行，注意为了保证复杂度，如果有向上延伸相同距离的状态我们只能保留一个。

问题是取 min，由于刚才我们已经要求平衡树按第一维排序，我们不好直接求全局 min，但是注意到如果一个状态相比于另一个能覆盖更前面的边但是花费也更小，我们不必保留另一个状态，因此在满足一维排好序的情况下另一位也排好了。平衡树可以用 set，时间复杂度 \(O((n+m)\log^2 n)\)，但是空间复杂度变成了线性，可以通过。

// Problem: Roads in Yusland
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF671D
// Memory Limit: 250 MB
// Time Limit: 4000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#define ll long long
#define N 300005
using namespace std;
ll read(){
	ll x=0;char ch=getchar();
	while(ch<'0' || ch>'9') ch=getchar();
	while(ch>='0' && ch<='9'){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x;
}
ll e,head[N<<1],nex[N<<1],to[N<<1],dep[N],tag[N],rt[N];
struct Node{
	ll num,val;
	bool operator <(const Node &x)const{
		return num>x.num;
	}
};
vector<Node> E[N];
set<Node> t[N];
void add(ll u,ll v){
	to[++e]=v;nex[e]=head[u];head[u]=e;
	to[++e]=u;nex[e]=head[v];head[v]=e;
}
ll flag;
void insert(ll u,ll num,ll val){
	if(t[u].size()==0){t[u].insert((Node){num,val});return;}
	auto it=t[u].lower_bound((Node){num,val});
	if(it==t[u].end() || (it->num)!=num){
		if(it!=t[u].end() && it->val<=val)return;
		if(it==t[u].begin()){t[u].insert((Node){num,val});return;}
		auto itr=it,itl=it;
		while(itl!=t[u].begin()){
			itl--;if(itl->val<val){itl++;break;}
		}
		if(itl!=itr)t[u].erase(itl,itr);
		t[u].insert((Node){num,val});return;
	}
	if(it->val<=val) return;
	it++;auto itr=it;it--;
	while(it!=t[u].begin()){
		it--;if(it->val<val){it++;break;}
	}
	t[u].erase(it,itr);
	t[u].insert((Node){num,val});
}
void dfs(ll u,ll fa){
	rt[u]=u;
	ll tot=0;dep[u]=dep[fa]+1;
	for(ll i=head[u];i;i=nex[i]){
		ll v=to[i];if(v==fa) continue;
		dfs(v,u);if(flag) return;
		if(t[rt[v]].size()==0){flag=1;return;}
		if((t[rt[v]].begin()->num)>dep[u])t[rt[v]].erase(t[rt[v]].begin());
		if(t[rt[v]].size()==0){flag=1;return;}
		tot+=(t[rt[v]].begin()->val+tag[v]);tag[v]=-(t[rt[v]].begin()->val);
	}
	ll tmp=300001;
	for(ll i=head[u];i;i=nex[i]){
		ll v=to[i];if(v==fa) continue;
		if(t[rt[v]].size()>t[rt[u]].size()){tmp=v;rt[u]=rt[v];tag[u]=tot+tag[v];}
	}
	for(ll i=head[u];i;i=nex[i]){
		ll v=to[i];if(v==fa || rt[v]==rt[u]) continue;
		for(auto it=t[rt[v]].begin();it!=t[rt[v]].end();it++){
			insert(rt[u],it->num,it->val+tag[v]-tag[tmp]);
		}
	}
	for(ll i=0;i<E[u].size();i++){
		insert(rt[u],dep[E[u][i].num],E[u][i].val-tag[tmp]);
	}
}
int main(){
	ll n,m,u,v,w;n=read();m=read();
	for(ll i=1;i<n;i++){u=read();v=read();add(u,v);}
	for(ll i=1;i<=m;i++){
		u=read();v=read();w=read();E[u].push_back((Node){v,w});
	}
	if(n==1){cout<<0;return 0;}
	dfs(1,0);
	if(flag) cout<<-1;
	else cout<<(t[rt[1]].begin()->val)+tag[1];
	return 0;
}