树形DP - hdu5293 Tree chain problem

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=5293

题意：

给定一棵树，再给出若干树上的链，每条链拥有一个权值，问如何挑选这些链能使得权值之和最大，且被选中的链没有公共结点，求最大权值

思路：

看题解的过程中有看到用离线lca+时间戳+树形dp解法的，感觉那种解法会更加高大上...嗯不会离线lca所以这题用了树链剖分+线段树+树形dp解的

因为题目给树链的方式只给了该链的起止结点，对于这种求树上两点路径直观感觉就是树链剖分，先剖分再搜出每条链的lca，然后做树形DP

dp[i]: 以i为根的子树，能得到的最大权值

sum[i]: sum[i] = dp[k] 其中k为i的所有子结点

状态转移方程为: 

不选中i点，则所有lca为i的链都不会被选中: dp[i] = sum[i]

选中i点，则对所有lca为i的链j均有: dp[i] = value[j] + (sum[k] - dp[k]) + dp[i]

其中value[j]为链j的权值，k为所有在链j上的节点

到此为止用到了树链剖分和树形dp，然而会超时...观察到状态转移时用到了树上某条链的结点sum之和 及 dp之和，用线段树维护这两个和，才可以在规定时间内通过

代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<functional>
#pragma comment(linker, "/STACK:102400000,102400000")//C++
using namespace std;

const double PI = 3.141592653589793238462643383279502884197169399;
const int MAXINT = 0x7fffffff;
const int MAXSIZE = 100000 + 5;

int n;
int fa[MAXSIZE], siz[MAXSIZE], son[MAXSIZE], dep[MAXSIZE], top[MAXSIZE], tid[MAXSIZE];
int dp[MAXSIZE], sum[MAXSIZE];
//vector<int> l[MAXSIZE];
int lsum,lfirst[MAXSIZE],lnext[MAXSIZE],lto[MAXSIZE];
int first[MAXSIZE], gnext[2*MAXSIZE], to[2*MAXSIZE], edge;
int tsum;
int res;

struct noder{
    int u, v, weight;
};
noder arr[MAXSIZE];

struct node{
	int l, r;
	int dsum,ssum;
	int mid(){
		return (l + r) / 2;
	}
};
node tree[MAXSIZE * 4 + 5];

//初始状态 BuildTree(0,1,n)
void BuildTree(int root, int l, int r){
	tree[root].l = l; tree[root].r = r;
	tree[root].dsum = 0; tree[root].ssum = 0;
	if (l != r){
		BuildTree(root * 2 + 1, l, (l + r) / 2);
		BuildTree(root * 2 + 2, (l + r) / 2 + 1, r);
	}
	return;
}

//线段节点初始化 (0,i,w)
void t_insert(int root, int i, int d, int s){
	if (tree[root].l == tree[root].r){
        tree[root].ssum = s;
        tree[root].dsum = d;
        return;
	}
	else{
		if (i <= tree[root].mid())
			t_insert(root * 2 + 1, i, d, s);
		else t_insert(root * 2 + 2, i, d, s);
        tree[root].ssum = tree[(root<<1) + 1].ssum + tree[(root<<1) + 2].ssum;
        tree[root].dsum = tree[(root<<1) + 1].dsum + tree[(root<<1) + 2].dsum;
	}
}

//查询线段[st,en] (0,st,en)
void t_query(int root, int st, int en){
	if (tree[root].l == st && tree[root].r == en){
		res -= tree[root].dsum;
		res += tree[root].ssum;
		return;
	}
	if (st>tree[root].mid()){
		t_query(root * 2 + 2, st, en);
	}
	else if (en <= tree[root].mid()){
		t_query(root * 2 + 1, st, en);
	}
	else{
		t_query(root * 2 + 1, st, tree[root].mid());
		t_query(root * 2 + 2, tree[root].mid() + 1, en);
	}
	return;
}

void dfs_1(int v,int father,int depth){
    siz[v] = 1;
    dep[v] = depth;
    fa[v] = father;
    son[v] = 0;
    int i=first[v];
    while (i){
        int u = to[i];
        if (u!=father){
            dfs_1(u,v,depth+1);
            siz[v]+=siz[u];
            if (siz[u]>siz[son[v]]) son[v] = u;
        }
        i = gnext[i];
    }
    return;
}

void dfs_2(int v, int tp){
    tid[v] = ++tsum;
    top[v] = tp;
    if (son[v] != 0){
        dfs_2(son[v], top[v]);  //使重链在线段上连续
    }
    int i=first[v];
    while (i){
        int u = to[i];
        if (u!=fa[v] && u!=son[v]){
            dfs_2(u, u);
        }
        i = gnext[i];
    }
    return ;
}

int findLca(int u, int v){
    int f1 = top[u], f2 = top[v];
    int lca;
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(u,v);
        }
        u = fa[f1];
        f1 = top[u];
    }
    if (u == v) return u;
    else{
        if (dep[u]>dep[v]) swap(u,v);
        return u;
    }
}

void l_insert(int a,int b){
    lnext[++lsum] = lfirst[a];
    lfirst[a] = lsum;
    lto[lsum] =b;
}

void g_insert(int a, int b){
    gnext[++edge] = first[a];
    first[a] = edge;
    to[edge] = b;
}

void cal(int u,int v){
    int f1=top[u],f2=top[v];
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(u,v);
        }
        t_query(0, tid[f1], tid[u]);
        u=fa[f1];
        f1=top[u];
    }
    if (u!=v){
        if (dep[u] > dep[v]) swap(u,v);
        t_query(0, tid[u], tid[v]);
    }
    else t_query(0,tid[u],tid[v]);

    return ;
}

void deal(int v){
    int e = first[v];
    while (e){
        int u = to[e];
        if (u !=fa[v]){
            deal(u);
            sum[v] += dp[u];
        }
        e = gnext[e];
    }
    dp[v] = sum[v];
    t_insert(0, tid[v], dp[v], sum[v]);

    int temp = dp[v];
    int i=lfirst[v];
    while (i){
        int va = arr[lto[i]].u, vb = arr[lto[i]].v;
        res = arr[lto[i]].weight;
        cal(va,vb);
        res += dp[v];
        //cout<<"temp: "<<i<<" "<<res<<endl;
        if (res>temp) temp=res;
        i = lnext[i];
    }
    if (temp>dp[v]){
        dp[v] = temp;
        t_insert(0, tid[v], dp[v], sum[v]);
    }
//    cout<<"deal done! "<<v<<endl;
//    cout<<dp[v]<<" "<<sum[v]<<endl;
//    cout<<"deal done! "<<v<<endl;

}

void init(){
    memset(lfirst,0,sizeof(lfirst));
    memset(first,0,sizeof(first));
    memset(siz,0,sizeof(siz));
    memset(son,0,sizeof(son));
    memset(dep,0,sizeof(dep));
    memset(fa,0,sizeof(fa));
    memset(top,0,sizeof(top));
    memset(dp,0,sizeof(dp));
    memset(sum,0,sizeof(sum));
    edge=0;
    tsum=0;
    lsum=0;
}

int main(){
    int total,m;
    cin>>total;
    while (total--){
        init();
        scanf("%d %d",&n,&m);
        for (int i=1;i<n;++i){
            int a,b;
            scanf("%d %d",&a,&b);
            g_insert(a,b);
            g_insert(b,a);
        }

        dfs_1(1,0,0);
        dfs_2(1,1);

        for (int i=0;i<m;++i){
            scanf("%d %d %d",&arr[i].u, &arr[i].v, &arr[i].weight);
            int lca = findLca(arr[i].u, arr[i].v);
            l_insert(lca,i);
        }

        BuildTree(0,1,tsum);

        deal(1);

        printf("%d\n",dp[1]);
    }
    return 0;
}