题目描述

有一棵苹果树，如果树枝有分叉，一定是分2叉（就是说没有只有1个儿子的结点）

这棵树共有N个结点（叶子点或者树枝分叉点），编号为1-N,树根编号一定是1。

我们用一根树枝两端连接的结点的编号来描述一根树枝的位置。下面是一颗有4个树枝的树

2   5

 \ /

  3   4

   \ /

    1

现在这颗树枝条太多了，需要剪枝。但是一些树枝上长有苹果。

给定需要保留的树枝数量，求出最多能留住多少苹果。

输入输出格式

输入格式：
 

第1行2个数，N和Q(1<=Q<= N,1<N<=100)。

N表示树的结点数，Q表示要保留的树枝数量。接下来N-1行描述树枝的信息。

每行3个整数，前两个是它连接的结点的编号。第3个数是这根树枝上苹果的数量。

每根树枝上的苹果不超过30000个。

输出格式：
 

一个数，最多能留住的苹果的数量。

输入输出样例

输入样例#1： 复制

5 2

1 3 1

1 4 10

2 3 20

3 5 20

输出样例#1： 复制

21

算法分析：

 树形依赖背包的入门题，参考解析：​​选课​​

但与上一题有所不同，

1.这题明确给出根节点为1，所以不会是上一题的无根树

2.父节点和子结点不像上一题一样标准的给出，所以每一个结点就没有了明确的值。

3.这题要求删边对应上一题删点数目+1

这题遇上题一模一样，但是这题目没给标准的给你父节点和子节点，但在后面给你一个价值，这时候你不确定子节点是谁，所以值不能想上一题一样直接复制子节点，所以vextor就不好入手了，所以建树时要注意。

这就需要完整的链式向前星，需要保存边的值，在建好树后，赋值给对应的子节点。

推荐代码实现：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int N=310;
struct node
{
    int v;///终端点
    int next;///下一条同样起点的边号
    int w;///权值
}edge[N*2];///无向边，2倍
int head[N];///head[u]=i表示以u为起点的所有边中的第一条边是 i号边
int tot;  ///总边数
int minn;
void add(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
int n,m;
int dp[N][N],val[N];
void dfs(int u,int fa) 
{
    //dp[u][1]=val[u];///选一个肯定选自己这个结点
    for(int i=head[u];i!=-1;i=edge[i].next)
     {
        int v=edge[i].v;
        if(fa==v) continue;   ///如果下一个相邻节点就是父节点，则证明到底层了，开始递归父节点的兄弟节点
        dp[v][1]=edge[i].w;    ///每一个结点的赋值
        
        dfs(v,u);
        
        for(int j=m;j>0;j--)    ///背包容量
         ///下面这个循环必须是k<j结束，不能取等号，因为至少需要留一个点来取u点
        for(int k=0;k<j;k++)   ///选择用户
        { 
          dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]);
        }
     }
 
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
    
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp)); 
    tot=0;
    
  
    for(int i=1;i<n;i++)
    {
        int u,w,v;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
        add(v,u,w);///注意题目给出第一个不一定是父亲结点 
    }
    
    m+=1;   ///虚结点加1，删n条边相当于删除n个点
    dfs(1,-1);
    
    printf("%d\n",dp[1][m]);
    }
    
    return 0;
}

我一开始做的代码

代码实现：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int N=110;
struct node
{
    int v;///终端点
    int next;///下一条同样起点的边号
    int w;///权值
}edge[N*2];///无向边，2倍
int head[N];///head[u]=i表示以u为起点的所有边中的第一条边是 i号边
int tot;  ///总边数
void add(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
int n,m;
int dp[N][N];
///dp[i][j]表示节点i保留j个枝条的所剩苹果最大值
int dfs(int u,int fa) 
{
    int num=0;  ///num表示u节点的子节点数目
    for(int i=head[u];i!=-1;i=edge[i].next)
     {
        int v= edge[i].v;
        if(fa==v) continue;   ///如果下一个相邻节点就是父节点，则证明到底层了，开始递归父节点的兄弟节点
        num+=dfs(v,u)+1;
        for(int j=min(num,m);j>=1;j--)  ///注意删除有限制
            for(int k=min(j-1,num);k>=0;k--)
        {
           dp[u][j]=max(dp[u][j],dp[u][j-k-1]+dp[v][k]+edge[i].w);
        }
     }
    return num;
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp));
    tot=0;
    
    for(int i=1;i<n;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
        add(v,u,w);
    }
    dfs(1,-1);
    printf("%d\n",dp[1][m]);
    return 0;
}