【日常训练】回路（树形DP+时间复杂度分析/模拟费用流）

题目大意：

• 给定一棵 $n$ 个结点的树，我们将给出的树边称为一类边，边有边权。
• 然后现在你需要在树上加上恰好 $k$ 条二类边，$k$ 条边的端点可以任意选取，但是边权给定。
• 现在你要找到一条加边方案，使得树上满足以下条件的有向回路的边权和最小（一条边可以被重复经过，重复经过的边权重复累加）
  • 每条一类边至少经过一次
  • 每条二类边最多经过一次
• 求边权和。$n\le 10^5,k\le 100$。

算法分析：

• 首先我们知道当 $k=0$ 时原图的边权和的两倍即为答案，那么我们就考虑连边能从两倍边权和中减少的最大代价。
• 然后我们考虑把一条二类边连接上时，会有什么作用：
  
• 即选取 $u,v$ 两点连二类边，作用就是把代价减少 $dis(u,v)$。
• 然后再考虑再选一对点 $(x,y)$，这时可以发现 $(u,v)$ 和 $(x,y)$ 的路径交部分不能重复减少代价，反而这部分的代价要算成原来两倍的那种代价。

算法一：

• 根据上面分析，我们可以直接得到算法一。
• 即每次选取一条最长链，然后把最长链的边权取反。
• 将这个过程重复 $k$ 次，即得到减少的最大代价，得到答案。
• 这么做的正确性我们接下来证明。

算法二：

• 根据最开始的分析，将路径交给抵消掉，得到的有贡献的部分实际上是 $k$ 条边不相交的路径。
• 原问题就转化为了：在带权树上选取 $k$ 条边不相交的路径，使得边权和最大。
• 算法二是考虑用 $DP$，$f[u][i][0/1]$ 表示在 $u$ 的子树中选取 $i$ 条边不相交的路径，其中点 $u$ 是否是某一条路径的端点，的最大边权和。
• 转移比较显然，这里就不说了。
• 但是这里需要分析时间复杂度，因为下面的代码看起来是 $\mathcal{O}(n{k}^2)$ 的。

void dfs(int u)
{
	sze[u] = 1; 
	for (v : son[u])
	{
		dfs(v); 
		for (int i = 0; i <= min(k,sze[u]); ++i)
			for (int j = 0; j <= min(k, sze[v]); ++j)
			{ ... //该部分的时间复杂度是O(1) }
		sze[u] += sze[v];  
	}
}

• 称一个点，在它或它祖先中的转移，对应的循环变量的上界为该点的界。

• 为我们分类讨论一下 $sze[u],sze[v]$：

  • 若 $sze[u]\ge k,sze[v]\ge k$，则这样的合并次数不超过 $\lfloor \frac{n}{k}\rfloor$，时间复杂度 $\mathcal{O}(nk)$。
  • 若只有其中一个 $\ge k$，相当于小的那个子树的每个点的界用 $k$ 的时间，使界变为 $k$，每个点只会发生一次这样的变化，时间复杂度 $\mathcal{O}(nk)$。
  • 若 $sze[u]\le k,sze[v]\le k$，则相当于 $u$ 中的每个点用 $sze[v]$ 的时间使其界扩大 $sze[v]$，每个点最多扩大的值为 $k$，时间复杂度 $\mathcal{O}(nk)$。

• 接下来补充对算法一的说明。

• 因为问题转化为了 $k$ 条不相交的路径的最大边权和。

• 可以转化为一个费用流问题，即源点向每个点连边，每个点向汇点连边，原图连双向边，还需要一个点限制流量。

• 然后这个模型是比较特殊的，我们发现可以模拟费用流的过程，即算法一：每次取最长链，然后取反，取反后再选这条边就等价于退流。

• 算法一的正确性得证。

• 两种算法的时间复杂度均为 $\mathcal{O}(nk)$。

• 属于简单题，但是这里树形 $DP$ 的时间复杂度分析是比较经典的。

#include <bits/stdc++.h>

template <class T>
inline void read(T &x)
{
	static char ch; 
	static bool opt; 
	while (!isdigit(ch = getchar()) && ch != '-'); 
	x = (opt = ch == '-') ? 0 : ch - '0'; 
	while (isdigit(ch = getchar()))
		x = x * 10 + ch - '0'; 
	if (opt) x = ~x + 1; 
}

template <class T>
inline void putint(T x)
{
	static char buf[15], *tail = buf; 
	if (!x) putchar('0'); 
	else
	{
		if (x < 0) putchar('-'), x = ~x + 1; 
		for (; x; x /= 10) *++tail = x % 10 + '0'; 
		for (; tail != buf; --tail) putchar(*tail); 
	}
}

template <class T>
inline void relax(T &x, const T &y)
{
	if (x < y) x = y; 
}

const int MaxM = 1e2 + 5; 
const int MaxNV = 1e5 + 5; 
const int MaxNE = MaxNV << 1; 

struct halfEdge
{
	int v, w;
	halfEdge *next; 
}adj_pool[MaxNE], *adj[MaxNV], *adj_tail = adj_pool; 

#define trav(u) for (halfEdge *e = adj[u]; e; e = e->next)

int n, m, w[MaxNV], sze[MaxNV]; 
int f[MaxNV][MaxM][2], g[MaxM][2]; 

inline void addEdge(int u, int v, int w)
{
	adj_tail->v = v; 
	adj_tail->w = w; 
	adj_tail->next = adj[u]; 
	adj[u] = adj_tail++; 
}

inline void dfs(int u, int pre)
{
	sze[u] = 1; 
	f[u][0][0] = f[u][1][1] = 0; 
	trav(u) if (e->v != pre)
	{
		dfs(e->v, u); 
		
		memset(g, 0, sizeof(g)); 
		for (int i = 0; i <= m && i <= sze[u]; ++i)
		{
			for (int j = 1; i + j <= m + 1 && j <= sze[e->v]; ++j)
			{
				if (i)
				{
					relax(g[i + j][1], f[u][i][1] + f[e->v][j][0]); 
					relax(g[i + j - 1][0], f[u][i][1] + f[e->v][j][1] + e->w);
				}
				relax(g[i + j][0], f[u][i][0] + f[e->v][j][0]); 
				relax(g[i + j][1], f[u][i][0] + f[e->v][j][1] + e->w); 
				if (!f[e->v][j][0]) break; 
			}
		}
		for (int i = 0; i <= m; ++i)
		{

			for (int j = 0; j <= 1; ++j)
				relax(f[u][i][j], g[i][j]); 
			relax(f[u][i + 1][1], f[u][i][0]); 
			relax(f[u][i][0], f[u][i][1]); 
		}
		sze[u] += sze[e->v]; 
	}
}

int main()
{
	freopen("yist.in", "r", stdin); 
	freopen("yist.out", "w", stdout); 
	

	read(n), read(m); 

	int tot = 0; 
	for (int i = 1; i < n; ++i)
	{
		int u, v, w; 
		read(u), read(v), read(w); 
		addEdge(u, v, w); 
		addEdge(v, u, w); 

		tot += w; 
	}

	tot <<= 1; 

	for (int i = 1; i <= m; ++i)
		read(w[i]); 
	std::sort(w + 1, w + m + 1); 

	dfs(1, 0); 

	int ans = 0, sum = 0; 
	for (int i = 1; i <= m; ++i)
	{
		sum += w[i]; 
		if (f[1][i][0] <= sum) break; 

		relax(ans, f[1][i][0] - sum); 
	}

	printf("%d\n", tot - ans); 
	
	return 0; 
}