POJ 1947 Rebuilding Roads

最新推荐文章于 2020-10-14 21:10:18 发布

原创最新推荐文章于 2020-10-14 21:10:18 发布 · 623 阅读

1 ·

CC 4.0 BY-SA版权

ACM_动态规划专栏收录该内容

39 篇文章

订阅专栏

本文介绍了一种结合树形动态规划与分组背包算法的解决方案，用于求解从给定树中截取特定大小子树的问题。通过深度优先搜索（DFS）遍历树结构并应用动态规划技巧，实现了对不同节点作为根节点时最小边数的计算。

树形DP+分组背包

题意：给一棵n个节点的树编号1~n，要从中截出一棵k个节点的树，最少需要删除几条边

思路：设dp[i][j]为以节点i为根的子树删除j个节点需要删除的最小边数

由于根貌似没有给定，所以我加的双向边

随便找个节点为根DFS一遍，对每个节点作1~num[i]-1的分组背包（-1是因为最多只能删num[i]-1个节点）（num[i]是以节点i为根的子树的节点总数）

注意到状态的原因，所以当前子树剩下的节点数是num[i]-dp[i][j]。计算结果的时候注意一下根与非根的差别，非根子树还需要删除一条连向父亲的边。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int MAXN = 200;
const int INF = ~0u>>1;
int max(int a, int b) { return a>b?a:b; }
int min(int a, int b) { return a<b?a:b; }

struct E{
	int v, next;
}edge[MAXN<<1];
int head[MAXN],tot;
int n,w;
int ans;
int dp[MAXN][MAXN];
int num[MAXN];

void add_edge(int u, int v)
{
	edge[tot].next = head[u];
	edge[tot].v = v;
	head[u] = tot ++;
}

void dfs(int u, int fa)
{
	int p;
	int i,j,v;
	num[u] = 1;
	for(p=head[u]; p!=-1; p=edge[p].next)
	{
		int v = edge[p].v;
		if(v == fa) continue;
		dfs(v,u);
		num[u] += num[v];
	}

	dp[u][num[u]] = 1;
	for(p=head[u]; p!=-1; p=edge[p].next)
	{
		v = edge[p].v;
		if(v== fa) continue;
		for(i=num[u]-1; i>=0; i--)
		{
			if(dp[u][i] == INF) continue;
			for(j=min(num[v],num[u]-i-1); j>=0; j--)
			{
				if(dp[v][j] == INF) continue;
				dp[u][i+j] = min(dp[u][i+j], dp[u][i]+dp[v][j]);
			}
		}
	}
	if(num[u]>w && dp[u][num[u]-w]+(fa==-1?0:1) < ans) ans = dp[u][num[u]-w]+(fa==-1?0:1);
	if(num[u] == w) ans = min(ans,fa==-1?0:1);

/*	printf("********************\n");
	printf("Node:%d num[u]:%d\n", u,num[u]);
	for(i=0; i<=num[u]; i++)
	{
		printf("cut = %d, cost = %d\n", i,dp[u][i]);
	}
	printf("ans = %d\n", ans);
	printf("********************\n\n");*/
}

int main()
{
	int i,j;
	int a,b;
	while(~scanf("%d%d", &n, &w))
	{
		tot = 0;
		ans = INF;
		memset(head, -1, sizeof(head));
		for(i=0; i<n-1; i++)
		{
			scanf("%d%d", &a, &b);
			add_edge(a,b);
			add_edge(b,a);
		}
		for(i=0; i<=n; i++)
			for(j=1; j<=n; j++) dp[i][j] = INF;
		for(i=1; i<=n; i++) dp[i][0] = 0;
		dfs(1,-1);
		printf("%d\n", ans);
	}
	return 0;
}