HDU5293 Tree chain problem

HDU5293 Tree chain problem

Problem Description

Coco has a tree, whose vertices are conveniently labeled by 1,2,…,n.

There are m chain on the tree, Each chain has a certain weight. Coco would like to pick out some chains any two of which do not share common vertices.

Find out the maximum sum of the weight Coco can pick

Input

The input consists of several test cases. The first line of input gives the number of test cases T (T<=10).

For each tests:

First line two positive integers n, m.(1<=n,m<=100000)

The following (n - 1) lines contain 2 integers ai bi denoting an edge between vertices ai and bi (1≤ai,bi≤n),

Next m lines each three numbers u, v and val$（1≤u，v≤n，0<val<1000）$, represent the two end points and the weight of a tree chain.

Output

For each tests:

A single integer, the maximum number of paths.

Sample Input

1

7 3

1 2

1 3

2 4

2 5

3 6

3 7

2 3 4

4 5 3

6 7 3

Sample Output

6

Hint

Stack expansion program：

#pragma comment(linker, "/STACK:1024000000,1024000000")


Task：

给定一棵树以及一些树上的路径，每一个路径都有价值，从这些路径中取出若干个，使得选出的路径没有公共点。求最大的价值和。

Solution：

考虑树形dp。如图，对于每个点，它的dp值可以是它的各个儿子的dp值之和，或者是对于以该点为LCA的路径，路径上各点的不在路径上的儿子的dp值相加（图中红色点）。

但是这样复杂度为$O(n^2)$，而且这个转移方程没有优化的余地了，因此我们尝试去优化这个dp方程：

设$sum[i]$表示$i$点所有儿子的dp值之和，链上的dp转移就变成了链上的所有点的sum值之和减掉链上所有点除根节点的dp值之和：

设点集K为一个LCA为i点的链。

$$dp[i]=max(\sum_j^{j\in son[i]}dp[j],\sum_k^{k\in K}sum[k]-\sum_t^{t\in K\land t!=i}dp[t])$$

（当然神犇已经发现了，这个其实记一个$f[i]=sum[i]-dp[i]$就可以了，我这里仍然采用两个数组分开的做法）

当然到了这一步，就可以直接用树链剖分将它的复杂度优化$O(nlog^2n)$，但是对于这种问题，可以直接用dfs序结合树状数组将复杂度优化到$O(nlogn)$：

在树状数组中$i$点的值保存为根至$i$点的路径上的点权和，修改$i$点时，将$L[i]$的位置加上值，$R[i]+1$处减掉该值即可。查询$i$点至$j$点的路径和时，只需要在树状数组中查询$[L[i],L[j]]$的和即可。

#include<stdio.h>
#include<ctype.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<vector>
#define S 18
#define M 100005
using namespace std;
struct Edge{int to,nxt;}Edge[M<<1];
struct Que{int a,b,lca,w;}Q[M];
vector<int>G[M];
int tot,n,m,L[M],R[M],dp[M],Sum[M],Head[M],fa[S+2][M];
struct BIT{
    int val[M];
    int lowbit(int x){return x&(-x);}
    void Add(int x,int v){
        while(x<=n){
            val[x]+=v;
            x+=lowbit(x);
        }
    }
    int Query(int x){
        int res=0;
        while(x){
            res+=val[x];
            x-=lowbit(x);
        }
        return res;
    }
    void clear(){
        memset(val,0,sizeof(val));
    }
}SUM,DP;
struct Std{
    void Init(){
        memset(Head,-1,sizeof(Head));tot=0;
        memset(dp,0,sizeof(dp));
        memset(Sum,0,sizeof(Sum));
        memset(fa,-1,sizeof(fa));
        SUM.clear(),DP.clear();
        for(int i=1;i<=n;i++)G[i].clear();
    }
    inline void Rd(int &res){
        char c;res=0;
        while(c=getchar(),!isdigit(c));
        do{
            res=(res<<1)+(res<<3)+(c^48);
        }while(c=getchar(),isdigit(c));
    }
    void Addedge(int a,int b){
        Edge[++tot].to=b;Edge[tot].nxt=Head[a];Head[a]=tot;
        Edge[++tot].to=a;Edge[tot].nxt=Head[b];Head[b]=tot;
    }
}Std;
struct Tree{
    int depth[M],sz;
    void dfs(int x,int f){
        L[x]=++sz;
        fa[0][x]=f;
        for(int i=Head[x];~i;i=Edge[i].nxt){
            int to=Edge[i].to;
            if(to==f)continue;
            depth[to]=depth[x]+1;
            dfs(to,x);
        }
        R[x]=sz;
    }
    int LCA(int a,int b){
        if(depth[a]>depth[b])swap(a,b);
        for(int i=0;i<=S;i++)
            if((1<<i)&(depth[b]-depth[a]))b=fa[i][b];
        if(a==b)return a;
        for(int i=S;i>=0;i--)
            if(fa[i][a]!=fa[i][b])a=fa[i][a],b=fa[i][b];
        return fa[0][a];
    }
    void Init(){
        sz=0;depth[1]=0;
        dfs(1,-1);
        for(int i=1;i<=S;i++)
            for(int j=1;j<=n;j++)
                if(fa[i-1][j]!=-1)fa[i][j]=fa[i-1][fa[i-1][j]];
        for(int i=1;i<=m;i++){
            int a=Q[i].a,b=Q[i].b;
            int c=LCA(a,b);
            G[c].push_back(i);
        }
    }
}Tree;
struct Main{
    void solve(int x,int f){
        for(int i=Head[x];~i;i=Edge[i].nxt){
            int to=Edge[i].to;
            if(to==f)continue;
            solve(to,x);
            Sum[x]+=dp[to];
        }
        dp[x]=Sum[x];
        for(int i=0;i<G[x].size();i++){
            int t=G[x][i];
            int sum=SUM.Query(L[Q[t].a])+SUM.Query(L[Q[t].b])-2*SUM.Query(L[x])+Sum[x];
            int res=DP.Query(L[Q[t].a])+DP.Query(L[Q[t].b])-2*DP.Query(L[x]);
            int k=sum-res+Q[t].w;
            if(k>dp[x])dp[x]=k;
        }
        DP.Add(L[x],dp[x]);
        DP.Add(R[x]+1,-dp[x]);
        SUM.Add(L[x],Sum[x]);
        SUM.Add(R[x]+1,-Sum[x]);
    }
}Main;
int main(){
    int T;
    Std.Rd(T);
    while(T--){
        Std.Rd(n);Std.Rd(m);
        Std.Init();
        for(int i=1;i<n;i++){
            int a,b;
            Std.Rd(a);Std.Rd(b);
            Std.Addedge(a,b);
        }
        for(int i=1;i<=m;i++){
            Std.Rd(Q[i].a);
            Std.Rd(Q[i].b);
            Std.Rd(Q[i].w);
        }
        Tree.Init();
        Main.solve(1,-1);
        printf("%d\n",dp[1]);
    }
    return 0;
}