Hdu 6820 Tree —— 无聊的树形DP

This way

题意：

现在有一棵树，让你在其中选择一个连通块，使得这个连通块度数大于k的节点数不超过1个，并且所有在连通块内的边权和最大。

题解：

一开始题目看错了，以为是个签到题，搞了一个小时陷入自我怀疑之后去看了Clarification才知道k是对于选择之后的连通块来说的，那么重新构思了一下就变成了一个比较套路的水题目。
首先我想着对于每一个位置是度数大于k的情况。但是很明显不能$O(n^2)$去做，那么就用树形DP去做。首先dp[i][0]表示第i个位置连向father的最大答案，dp[i][1]表示第i个位置不连向fa的答案，那么很明显dp[i][0]可以取的儿子数不超过k-1个，fa[i][1]不超过k个。dfs就是做出每个dp，并且由于我们要取的儿子的权值是最大的，那么我们对于每个位置都将它的儿子的权值排个序，取出需要的那么多个。
然后接下来就是说dfs每个位置是连边大于k的节点，那么对于每个节点都有两种情况：
1.将父亲传过来的值传下去，此时就需要用到dp[x][0]。
2.这个连通块作为新的连通块，与父亲分开，那么就是dp[x][1]。
然后每种情况都有两种情况：
首先如果我们枚举的下一个点(ne)的权值是被x(当前点)取到的，x就要减去dp[ne][0]，就表示需要将它的贡献减掉。
还有一种情况就是它没被x取到，那么我们是将被x取到的权值最小的连边断开，去连这个边。
vec[x]表示x的所有儿子的贡献

		if(x==1){
            if(i>=k)
                dfs2(ne,x,s+dp[x][0]-vec[x][k-1].v+vec[x][i].v-dp[vec[x][i].x][0]);
            else
                dfs2(ne,x,s+dp[x][0]-dp[vec[x][i].x][0]);
        }

这里就表示如果x是根节点，那么就表示这个是一个新的连通块(dp[x][0]和dp[x][1]在这里都是一样的)
dp[x][0]-vec[x][k-1].v+vec[x][i].v-dp[vec[x][i].x][0])
表示这个位置的贡献原先没被x取到，所以为了能够x连向ne，需要将将贡献最小的边断掉，也就是-vec[x][k-1]，再加上x连向ne的边的权值，我这里不想再用一个数组维护每两个点的权值了，所以就用vec[x][i].v-dp[vec[x][i].x][0]表示x和ne连边的权值。
下面的都类似，注意判这个点作为新连通块是否是最优的。

#include
using namespace std;
#define ll long long
#define pil pair
#define pli pair
const int N=2e5+5;
ll dp[N][2],ans;//0:link with fa
vector<pil>son[N];
struct node{
    int x;
    ll v;
    bool operator< (const node& a)const {
        return v>a.v;
    }
};
vector<node>vec[N];
int k;
void dfs(int x,int fa){
    int sz=son[x].size();
    for(auto i:son[x]){
        int ne=i.first;
        ll v=i.second;
        if(ne==fa)continue;
        dfs(ne,x);
        vec[x].push_back({ne,dp[ne][0]+v});
    }
    sort(vec[x].begin(),vec[x].end());
    for(int i=0;i<min((int)vec[x].size(),x==1?k:k-1);i++)
        dp[x][0]+=vec[x][i].v;
    for(int i=0;i<min((int)vec[x].size(),k);i++)
        dp[x][1]+=vec[x][i].v;
}
void dfs2(int x,int fa,ll s){
    for(int i=0;i<vec[x].size();i++){
        int ne=vec[x][i].x;
        ll v=vec[x][i].v;
        if(x==1){
            if(i>=k)
                dfs2(ne,x,s+dp[x][0]-vec[x][k-1].v+vec[x][i].v-dp[vec[x][i].x][0]);
            else
                dfs2(ne,x,s+dp[x][0]-dp[vec[x][i].x][0]);
        }
        else{
            if(i>=k)
                dfs2(ne,x,max(s+dp[x][0]-vec[x][k-2].v+vec[x][i].v-dp[vec[x][i].x][0],dp[x][1]-vec[x][k-1].v+vec[x][i].v-dp[vec[x][i].x][0]));
            else if(i==k-1)
                dfs2(ne,x,max(s+dp[x][0]-vec[x][k-2].v+vec[x][i].v-dp[vec[x][i].x][0],dp[x][1]-dp[vec[x][i].x][0]));
            else
                dfs2(ne,x,max(s+dp[x][0]-dp[vec[x][i].x][0],dp[x][1]-dp[vec[x][i].x][0]));
        }
    }
    ll sum=0;
    for(int i=0;i<vec[x].size();i++)
        sum+=vec[x][i].v;
    ans=max(ans,sum+s);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d%d",&n,&k);
        for(int i=1;i<=n;i++){
            son[i].clear();
            vec[i].clear();
            dp[i][0]=dp[i][1]=0;
        }
        int x,y;
        ll w;
        for(int i=1;i<n;i++)
            scanf("%d%d%lld",&x,&y,&w),son[x].push_back({y,w}),son[y].push_back({x,w});
        if(k==0){
            printf("0\n");
            continue;
        }
        ans=0;
        if(k==1){
            for(int i=1;i<=n;i++){
                ll sum=0;
                for(auto j:son[i])
                    sum+=j.second;
                ans=max(ans,sum);
            }
            printf("%lld\n",ans);
            continue;
        }

        dfs(1,0);
        dfs2(1,0,0);
        printf("%lld\n",ans);
    }
    return 0;
}