poj1947 Rebuilding Roads-CSDN博客

本文链接：https://blog.csdn.net/ctxdecs/article/details/23367145

Rebuilding Roads

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 8687		Accepted: 3911

Description

The cows have reconstructed Farmer John's farm, with its N barns (1 <= N <= 150, number 1..N) after the terrible earthquake last May. The cows didn't have time to rebuild any extra roads, so now there is exactly one way to get from any given barn to any other barn. Thus, the farm transportation system can be represented as a tree.

Farmer John wants to know how much damage another earthquake could do. He wants to know the minimum number of roads whose destruction would isolate a subtree of exactly P (1 <= P <= N) barns from the rest of the barns.

Input

* Line 1: Two integers, N and P

* Lines 2..N: N-1 lines, each with two integers I and J. Node I is node J's parent in the tree of roads.

Output

A single line containing the integer that is the minimum number of roads that need to be destroyed for a subtree of P nodes to be isolated.

Sample Input

Sample Output

Hint

[A subtree with nodes (1, 2, 3, 6, 7, 8) will become isolated if roads 1-4 and 1-5 are destroyed.]

题目大意：给定一棵树（对树进行裁剪），问要获得p个节点的子树，最少需要剪去多少次。

分析：设dp[r][p] 为以r为根节点的子树，留下p个节点所需要的最少剪枝次数

假设r有m个孩子，那么就要分两种情况进行讨论，（当前选择k（r的孩子））

1.当把k从r中去掉，那么dp[r][p] + 1;

2.当不去掉k的时候，那么对于当前这k来说dp[r][p] = dp[r][i] + dp[k][p-i]（0<=i<=p）, 其中i为r上节点（不包括k上的节点）

而要找最小的所以就要遍历r的所有的孩子，dp[r][p] = min(dp[r][i] + dp[k][p-i]) (k为r的孩子)；

3.总上dp[r][p] = min(1, 2),第一种和第二种最小的一个

源码：

#include <stdio.h>
#include <string.h>
struct Node
{
    int to, next;
};

int son[152];
int brother[152];
int dp[152][152];
int n, p, cnt;

int min(int a, int b)
{
    return a<b?a:b;
}

// dfs每个孩子节点是否剪掉
1.如果剪掉这个孩子（k），就要+1
2.如果不减掉（k）, 就要找最小剪数（父节点留下的节点数所需要的剪数+k留下的节点数）

void dfs(int r)
{
    for (int i=0; i<=p ;++i)
        dp[r][i] = 0x3ffffff;

    dp[r][1] = 0;	// 递归到最后以r为根的子树，就它自己一个点
    for (int i=son[r]; i; i=brother[i])	// 查找以r为根节点的孩子
    {
        int v = i;
        dfs(v);		
        for (int j=p; j>=0; --j)	// 必须从p开始
        {
            int tmp = dp[r][j] + 1; // 去掉v这个子树（加一次）
            for (int k=0; k<=j; ++k)
            {
                tmp = min(tmp, dp[v][j-k]+dp[r][k]);	// 如果不减v这个子树
														// （就是v余下的节点数的剪数+r的节点的剪数）
														// 还要选择一个最小的
            }
            dp[r][j] = tmp;	// 最后得出r留下j个节点所需要的剪数
            //printf("%d,%d:%d\n", r, j, dp[r][j]);
        }
    }
}

int main()
{
    int u, v;
    while (~scanf("%d%d", &n, &p))
    {
        cnt = 0;
        memset(son, 0, sizeof(son));
        for (int i=1; i<n; ++i)
        {
            scanf("%d%d", &u, &v);
            brother[v] = son[u];	// u为父节点，v的兄弟就是u的孩子
            son[u] = v;				// u的孩子
        }
        int ans; 
        dfs(1);
        ans = dp[1][p];	// 首先保留一个值
        for (int j=1; j<=n; ++j)
        {
            if (ans > dp[j][p])	// 寻找
				ans = dp[j][p] + 1;	// 不要忘了剪掉父亲的（如果不是根节点）
        }
        printf("%d\n", ans);

    }
    return 0;
}