Paths(升级版)---3011

题意

有一棵树，树的节点编号为1,2,…,n。
树上有m条路径，现在要从这些路径中选一些，选出的路径不能有公共点。
每条路径有一个权值，求选出哪些路径，是的权值最大。

思路：

如上图，此题实际上就是在可选择的边上多了权值的信息，然而，这就完全不是一道题目了…

dp[i]表示以i为根的子树的最大值；
sum[i]表示i的子节点的子树的dp之和；
也就是：val + ∑sum[i] - ∑dp[i]（i为链上的点）

但有这个∑在，固然会超时，所以要预处理，也就是做到O(1)查询一条链上的权值和。这个很简单，就是根到链上两个端点的和-根到两端点lca的和。
-> dis[a] + dis[b] - dis[lca(a,b)]；

但这样还不够，我们还要修改链上的信息，并要快速查询——线段树；
然而，这是树的形状，就要一个对应的序列——dfs序；

所以 $dp[i] = max(sum[i],sum[i]+val+∑dp( Segment tree) + ∑sum( Segment tree)$

总而言之：树型dp，前缀和维护dp，当然，之前还要求lca（倍增），查询维护最值（dfs序，线段树）。

#include<bits/stdc++.h>
#define REP(i,f,t) for(int i=(f),i##_end_=(t);i<=i##_end_;i++)
#define DREP(i,f,t) for(int i=(f),i##_end_=(t);i>=i##_end_;i--)
#define N 100005
#define M 21
#define root 1,n,1
#define lson L,mid,p<<1
#define rson mid+1,R,p<<1|1
#define family tree[p],tree[p<<1],tree[p<<1|1]
#define INF 0x3f3f3f3f
#define LL long long
// tree-dp sum hold beizeng lca xian duan shu hold  
using namespace std;
int n,m,T;
int fa[M][N],D[N],dfsL[N],dfsR[N];
vector<int>E[N];
struct edge{
    int from,to,val;
};
vector<edge>Q[N];
struct Node{
    int dp,sum;
};
struct node{
    int L,R;
    Node add;
}tree[N<<2];
struct Tree{
    void build(int L,int R,int p){
        tree[p].L=L,tree[p].R=R,tree[p].add.dp=tree[p].add.sum=0;
        if(L==R)return;
        int mid=(L+R)>>1;
        build(lson),build(rson);
    }
    void update(int L,int R,int p,Node x){
        if(tree[p].L==L && R==tree[p].R){
            tree[p].add.dp+=x.dp;
            tree[p].add.sum+=x.sum;
            return;
        }
        int mid=(tree[p].L+tree[p].R)>>1;
        if(R<=mid)update(L,R,p<<1,x);
        else if(L>mid)update(L,R,p<<1|1,x);
        else update(lson,x),update(rson,x);
    }
    Node Up(Node a,Node b){
        Node c;
        c.dp=a.dp+b.dp;
        c.sum=a.sum+b.sum;
        return c;
    }
    Node query(int x,int p){
        if(tree[p].L==tree[p].R)return tree[p].add;
        int mid=(tree[p].L+tree[p].R)>>1;
        if(x<=mid)return Up(tree[p].add,query(x,p<<1));
        else return Up(tree[p].add,query(x,p<<1|1));
    }
}Tree;
struct LCA{
    void Up(int &x,int step){
        REP(i,0,M-1)if(step&(1<<i))x=fa[i][x];
    }
    int Lca(int a,int b){
        if(D[a]>D[b])swap(a,b);
        Up(b,D[b]-D[a]);
        if(a==b)return a;
        DREP(i,M-1,0)if(fa[i][a]!=fa[i][b])a=fa[i][a],b=fa[i][b];
        return fa[0][a];
    }
    void Init(){
        REP(j,1,M-1)
            REP(i,1,n)
                fa[j][i]=fa[j-1][fa[j-1][i]];
    }
}LCA;
struct P100{
    int Dp[N],Sum[N];
    void dfs(int x,int f){
        dfsL[x]=++T;
        D[x]=D[f]+1;
        fa[0][x]=f;
        REP(i,0,E[x].size()-1){
            int y=E[x][i];
            if(y==f)continue;
            dfs(y,x);
        }
        dfsR[x]=T;
    }
    void Dfs(int x,int f){
        REP(i,0,E[x].size()-1){
            int y=E[x][i];
            if(y==f)continue;
            Dfs(y,x);
            Sum[x]+=Dp[y];
        }
        Dp[x]=Sum[x];
        REP(i,0,Q[x].size()-1){
            edge es=Q[x][i];
            Node a=Tree.query(dfsL[es.from],1);
            Node b=Tree.query(dfsL[es.to],1);
            Dp[x]=max(Dp[x],Sum[x]+Q[x][i].val+a.sum+b.sum-a.dp-b.dp);
        }
        Tree.update(dfsL[x],dfsR[x],1,(Node){Dp[x],Sum[x]});
    }
    void Clear(){
        T=0;
        REP(i,1,n)E[i].clear();
        REP(i,1,m)Q[i].clear();
        memset(fa,0,sizeof(fa));
        memset(D,0,sizeof(D));
        memset(dfsL,0,sizeof(dfsL));
        memset(dfsR,0,sizeof(dfsR));
        memset(Dp,0,sizeof(Dp));
        memset(Sum,0,sizeof(Sum));
    }
    void solve(){
        Clear();
        scanf("%d%d",&n,&m);
        REP(i,1,n-1){
            int a,b,c;
            scanf("%d%d",&a,&b);
            E[a].push_back(b);
            E[b].push_back(a);
        }
        dfs(1,0);
        LCA.Init();
        Tree.build(root);
        REP(i,1,m){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            int lca=LCA.Lca(a,b);
            Q[lca].push_back((edge){a,b,c});
        }
        Dfs(1,0);
        cout<<Dp[1]<<endl;
    }
}AC;
int main(){
    int T;
    scanf("%d",&T);
    while(T--)AC.solve();
    return 0;
}