Jzoj P5455 拆网线___树形dp

题目大意：

有$N$个机房，机房$A_i$和机房$i+1$相连，把$K$只企鹅安排到不同机房，要保证每只企鹅至少还能通过留下来的网线和至少另一只企鹅联机游戏。
问最少需要保留多少根网线。
数据有$T$组。

$2\le K\le N\le 100000，T\le 10$

分析：

要更优显然就要尽可能选出多的边满足两边都有企鹅，且企鹅仅有这一条边可以联系其他企鹅，设这样的边有$x$个
当$x\ast 2>=k$时，显然答案就是$\frac{a+1}{2}$
而当$x\ast 2<k$时，显然是选了$x$条边中，然后通过$(k-x\ast 2)$条边连接剩下的点，答案为$x+(k-x\ast 2)$
怎么求这样的边的数量呢，可以用到树形dp，
设
$dp[i][0]$表示以$i$为根的子树不含节点$i$中这样的边的数量。
$dp[i][1]$表示以$i$为根的子树中含节点$i$这样的边的数量。
然后对于每个节点$i$，都有
$dp[i][0]={\Sigma }_{j=1}^{n}dp[j][1](j为u儿子)$
求出了$dp[i][0]$以后，可以求出$dp[i][1]$
$dp[i][1]=max(dp[i][1],dp[i][0]-dp[son][1]+dp[son][0]+1)$
那么$x$就是$max(dp[1][0],dp[1][1])$

代码：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#define N 100005

using namespace std;

struct Node { int To, nxt; }e[2*N];
int f[N][2], ls[N], T, n, k, cnt, ans;

void Addedge(int u, int v)
{
    e[++cnt].To = v, e[cnt].nxt = ls[u], ls[u] = cnt;
}

void dfs(int x, int father)
{
	f[x][0] = f[x][1] = 0;
	for (int i = ls[x]; i; i = e[i].nxt)
	{
		 if (e[i].To == father) continue;
		 int y = e[i].To;
		 dfs(y, x);
		 f[x][0] += f[y][1];
	}
	for (int i = ls[x]; i; i = e[i].nxt)
	{
		 if (e[i].To == father) continue;
		 int y = e[i].To;
         f[x][1] = max(f[x][1], f[x][0] - f[y][1] + f[y][0] + 1);		 
	}
}

int main()
{
	freopen("tree.in","r",stdin);
	freopen("tree.out","w",stdout);
	scanf("%d", &T);
	while (T--)
	{
		   scanf("%d %d", &n, &k);
		   memset(f, 0, sizeof(f));
		   memset(ls, 0, sizeof(ls));
		   cnt = 0;
		   for (int i = 2; i <= n; i++)
		   {
		   	    int x;
		   	    scanf("%d", &x);
		        Addedge(i, x);
		        Addedge(x, i);
		   }
		   dfs(1, -1);
		   ans = max(f[1][0], f[1][1]);
		   if (ans * 2 >= k) printf("%d\n", k / 2 + k % 2);
		                else printf("%d\n", ans + (k - 2 * ans));
	}	
	return 0;
}