思路

首先可以想到dp[i][j]表示在i節點可以走j步獲得的最大值，其實就是類似於將j步分給它的子節點，樹上揹包問題。 但是這題還有一個要點，那就是當你分配給子節點一些步數後，可能還會回到i節點，所以需要考慮到底回不回i節點的問題，解決方法就是多加一維記錄是否回到i節點。 dp[i][j][0]表示不回，dp[i][j][1]表示回到i節點。 如果要回到i節點，那麼就必須多留出2步，如果不回到i節點，那麼只要1步。

程式碼

#pragma comment(linker, "/STACK:1024000000,1024000000") //加棧
#include <iostream>
#include <stdio.h>
 

#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#include <vector>
#include <set>
#include <string>
#include <math.h>
#include <stack>
using namespace std;
typedef long long ll;
const int maxn = 3e2+8;
#define inf 1000000000
int n,m;
vector
 
<int> g[maxn];
int h[maxn];
int dp[maxn][300][2];
void dfs(int u,int pre)
{
    for(int i=0;i<=m;i++) dp[u][i][0]=dp[u][i][1]=h[u];
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(v==pre) continue;
        dfs(v,u);
        for(int j=m;j>=1;j--)
        {
            for
 
(int k=1;k<=j;k++)
            {
                dp[u][j][0]=max(dp[u][j][0],dp[u][j-k][1]+dp[v][k-1][0]);
                dp[u][j][0]=max(dp[u][j][0],dp[u][j-k][0]+dp[v][k-2][1]);
                dp[u][j][1]=max(dp[u][j][1],dp[u][j-k][1]+dp[v][k-2][1]);
            }
        }
    }
}
int main(int argc, char const *argv[])
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++) g[i].clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&h[i]);
        }
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        dfs(1,0);
        printf("%d\n",max(dp[1][m][0],dp[1][m][1]));
    }
    return 0;
}