多校第一场1006

题目描述：

给出一棵树,n~1e5,然后给出m~1e5条特殊的链,每个链有一个权值.现在在树上挑选不相交的链,使得最后的拿到的权值最大.

题解：

看一个点,是树形dp,但是发现如果u是root,枚举过u的链,发现要暴力求和链上周围的点的dp和.这样会超时. 于是想到快速求一条链的和. 为了好写,我们把求链上连接的儿子的dp值的和转化到链上的权值. sum[u]指u的所有儿子的dp和,这个好想,那么一条链上的其实就是(sum[u] - 所有链上儿子d+链上儿子的sum-链上儿子儿子的d….),总结就是链上除了root,其他的点权值都是sum[v]-d[v].而root的权值是sum[root]. 我们是算d[u]的时候才用的,当时d[u]肯定就是0. 所以求链上的权值和. 我们有两种求法

(1)邓爷教的标序+lca. 这样求的是路径,我们用一种常用的方法,把i的值归到i到他fa的那条边上. 这样我们求路径+sum[root]就行了.

(2)用树链剖分. 映射到树状数组上,每次求和.

重点：

(1)关键是求一条链上的和.

(2)把权值归到链上,简化写法.

(3)点的权值归到u到fa的边上.

(4)标序或者树链剖分求链的和

(5)标序+st表求lca

代码：

//这个是标序算链的和.
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const int maxn = 1e5 + 100;
const int maxRMQ = 4e5 + 100;
const int maxIND = 2e5 + 1000;
const int maxTree = 1e6 + 100;
int nn, m;
struct Edge
{
int a, b, val;
};
vector<Edge> edge[maxn];
vector<int> G[maxn];
int st[maxRMQ][50], L2[maxRMQ], P2[50];

int dfn, index[maxn], fa_index[maxn], first_u[maxn];
int a_st[maxRMQ], an;

int dfx, getin[maxn], getout[maxn];
int d[maxn], sum[maxn];

//void pushUp(int rt)
//{
//    int lRt = (rt<<1), rRt = ((rt<<1)|1);
//    tree[rt] = tree[lRt]+tree[rRt];
//}
//void change(int pos, int key, int rt, int l, int r)
//{
//    if(l==r && l == pos)//主义同时修改tree
//    {
//        tree[rt] = key;
//        return;
//    }
//    pushDown(rt);
//    int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
//    if(pos <= mid)
//    {
//        change(pos,key, lRt, l, mid);
//    }
//    if(pos >= mid + 1)
//    {
//        change(pos, key, rRt, mid + 1, r);
//    }
//    pushUp(rt);//向上push
//}
//
//int query(int L, int R, int rt, int l, int r)
//{
//    if(L <= l && R >= r)//全包括
//    {
//        return tree[rt];
//    }
//    int ans =0, mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
//    if(L <= mid)
//    {
//        ans += query(L, R, lRt, l, mid);
//    }
//    if(R >= mid + 1)
//    {
//        ans += query(L, R, rRt, mid + 1, r);
//    }
//    return ans;
//}

void dfs_dfn(int u, int fa)//这是lca
{
dfn++;
index[u] = dfn;
fa_index[dfn] = u;
an++;
a_st[an] = dfn;
first_u[u] = an;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=fa)
{
dfs_dfn(v, u);
an++;
a_st[an] = index[u];
}
}
}
void getL2()
{
L2[1] = 0;
for(int i = 2; i<=400000; i++)
{
if((i&(i-1))==0)
{
L2[i] = L2[i-1]+1;
}
else
{
L2[i] = L2[i-1];
}
//printf("%d %d\n", i, L2[i]);
}
}
void initail()
{
P2[0] = 1;
for(int i = 1; i<=30; i++)
{
P2[i] = 2*P2[i-1];
}

for(int i = 1; i <= an; i++)
{
st[i][0] = a_st[i];
//printf(" i is %d  %d\n", i, a_st[i]);
}
for(int s = 1; s<=30; s++)
{
for(int i = 1; i+P2[s] - 1 <=an; i++)
{
int j = i+P2[s-1];
st[i][s] = min(st[i][s-1], st[j][s-1]);
}
}
}
int st_query(int a, int b)
{
int len = (b-a+1);
int s = L2[len];
return min(st[a][s], st[b-P2[s]+1][s]);
}
int getLca(int a, int b)//lca结束
{
int l = first_u[a], r = first_u[b];
if(l > r)
{
swap(l, r);
}
return fa_index[st_query(l, r)];
}

int tree[maxn << 1];//树状数组
int getsum(int x)
{
int ret = 0;
while (x)
{
ret += tree[x];
x -= (x & (-x));
}
return ret;
}
void update(int x, int y)
{
while (x <= dfx)
{
tree[x] += y;
x += (x & (-x));
}
}

void dfs_xu(int u, int fa)
{
dfx++;
getin[u] = dfx;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=fa)
{
dfs_xu(v, u);
}
}
dfx++;
getout[u] = dfx;
}

int getT(int a, int b)
{
if(a==1)
{
return getsum(b);
}
return getsum(b)-getsum(a-1);
}

int getSum_t(int a, int b, int lca)
{
int l = getin[lca];
int r = getin[a];
int ans = 0;
ans += getT(l, r);
r = getin[b];
ans += getT(l, r);
return ans;
}

void dfs(int u, int fa)//树形dp,求和链上.
{
sum[u] = 0;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=fa)
{
dfs(v, u);
sum[u] += d[v];
}
}
d[u] = sum[u];
REP(i, 0, edge[u].size())
{
Edge e = edge[u][i];
int a = e.a, b = e.b, val = e.val;
//        if(u == 2)
//        {
//            for(int i = 1; i<=dfx; i++)
//            {
//                printf("tree i is %d  %d\n", i, tree[i]);
//            }
//        }
int tmp = getSum_t(a, b, u);
d[u] = max(d[u], tmp + sum[u] + val);
}
//printf("%d  %d %d\n", u, sum[u], d[u]);
update(getin[u], sum[u]-d[u]);
update(getout[u], d[u]-sum[u]);

//change(getin[u], sum[u]-d[u], 1, 1, dfx);
//change(getout[u], d[u]-sum[u], 1, 1, dfx);
}
void solve()
{
REP_D(i, 1, nn)
{
G[i].clear();
edge[i].clear();
}
REP_D(i, 1, nn - 1)
{
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfn = 0;
an = 0;
dfs_dfn(1, 0);
initail();
REP_D(i, 1, m)
{
int a, b, val;
scanf("%d%d%d", &a, &b, &val);
int lca = getLca(a, b);
Edge t;
t.a = a;
t.b = b;
t.val = val;
edge[lca].push_back(t);
//printf("lca %d %d %d\n", a, b, lca);
}
CLR(tree);
CLR(sum);
CLR(d);
dfx = 0;
dfs_xu(1,0);
dfs(1, 0);
printf("%d\n", d[1]);
}

int main()
{
// freopen("13Min.txt", "r", stdin);
//freopen("1out.txt", "w", stdout);
int t;
getL2();
scanf("%d", &t);
while(t--)
{
scanf("%d%d", &nn,&m);
solve();
}
return 0;
}

//这个是树链剖分,但是线段树要re....所以没有过
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const int maxn = 1e5 + 100;
const int maxLMQ = 4*maxn+100;
const int MAXL = 30;
int st[maxLMQ][MAXL];
int an, a[maxLMQ];
int index[maxn], fa_index[maxn], first_byindex[maxn];
int dfn;
vector<int> G[maxn];

struct Edge
{
int a, b, val, lca;
};
Edge edge[maxn];
vector<Edge> lca_edge[maxn];
int edge_n;

int P2[maxn], L2[maxn];

int d[maxn], sum[maxn];
int dep[maxn], w[maxn], fa[maxn], top[maxn], son[maxn], siz[maxn];
int z;
int tree[maxLMQ];

int n;

void getP2()
{
P2[0] = 1;
for(int i = 1; i<=30; i++)
{
P2[i] = P2[i-1]*2;
}
}
void getL2()
{
L2[1] = 0;
for(int i = 2; i<=400000; i++)
{
if((i&(i-1))==0)
{
L2[i] = L2[i-1]+1;
}
else
{
L2[i] = L2[i-1];
}
//printf("%d %d\n", i, L2[i]);
}
}

void initail()
{
for(int i = 1; i <= an; i++)
{
st[i][0] = a[i];
}
for(int s = 1; s<=30; s++)
{
for(int i = 1; i<= an; i++)
{
int j = i+P2[s-1];
if(j>=an)
continue;
st[i][s]= min(st[i][s-1],st[j][s-1]);
}
}
}
int query(int l, int r)
{
int len = (r-l+1);
int s = L2[len];
int tmp = P2[s];
return min(st[l][s], st[r - tmp + 1][s]);
}
int getLca(int a, int b)
{
a = index[a];
b = index[b];
int l = first_byindex[a], r = first_byindex[b];
if(l > r)
{
swap(l, r);
}
return fa_index[query(l, r)];
}

void dfs_dfn(int u, int fa)
{
++an;
a[an] = dfn;
first_byindex[dfn] = an;
index[u] = dfn;
fa_index[dfn] = u;
dfn++;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=fa)
{
dfs_dfn(v, u);
an++;
a[an] = index[u];
}
}
}

void getEdge()
{
REP_D(i, 1, n)
{
lca_edge[i].clear();
}
REP(i, 0, edge_n)
{
scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].val);
edge[i].lca = getLca(edge[i].a, edge[i].b);
lca_edge[edge[i].lca].push_back(edge[i]);
}
}

void dfs_1(int u, int pat)//先准备
{
siz[u] = 1;
son[u] = 0;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=pat)
{
fa[v] = u;
dep[v] = dep[u]+1;
dfs_1(v, u);
if(son[u]==0)
{
son[u] = v;
}
else if(siz[v] > siz[son[u]])
{
son[u] = v;
}
siz[u] += siz[v];
}
}
}

void dfs_2(int u, int pat, int tp)//标号边
{
if(pat != 0)
{
z++;
w[u] = z;
}
top[u] = tp;
if(son[u] !=0)
{
dfs_2(son[u], u, top[u]);
}
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=pat&&v!=son[u])
{
dfs_2(v, u, v);
}
}
}

int query_tree(int LL, int RR, int rt, int l, int r)
{
if(LL<=l && RR>= r)
{
return tree[rt];
}
int ans = 0;
int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
if(LL<=mid)
{
ans += query_tree(LL, RR, lRt, l, mid);
}
if(RR>=mid+1)
{
ans += query_tree(LL, RR, rRt, mid+1, r);
}
return ans;
}
void pushUp(int rt)
{
int lRt = (rt<<1), rRt = ((rt<<1)|1);
tree[rt] = tree[lRt]+ tree[rRt];
}
void update(int pos, int x, int rt, int l, int r)
{
if(pos == l && pos == r)
{
tree[rt] = x;
return;
}
int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
if(pos <= mid)
{
update(pos, x, lRt, l, mid);
}
else
{
update(pos , x, rRt, mid +1, r);
}
pushUp(rt);
}

int getSum(int a, int b)
{
int f1 = top[a], f2 = top[b];
int ans = 0;
while(f1 != f2)
{
if(dep[f1] < dep[f2])
{
swap(f1, f2);
swap(a, b);
}
ans += (query_tree(w[f1], w[a], 1, 1, z));
a = fa[f1];
f1 = top[a];
}
if(a==b)
return ans;
if(dep[a] > dep[b])
{
swap(a, b);
}
ans += query_tree(w[son[a]], w[b], 1, 1, z);
return ans;
}

void dfs(int u, int pat)
{
sum[u]= 0;
REP(i, 0, G[u].size())
{
int v = G[u][i];
if(v!=pat)
{
dfs(v, u);
sum[u] += d[v];
}
}
d[u] = sum[u];
REP(i, 0, lca_edge[u].size())
{
Edge &e = lca_edge[u][i];
int a = e.a, b = e.b, val = e.val;
int temp = getSum(e.a, e.b);
d[u]=max(d[u], temp+sum[u]+val);
}
if(u!=1)
{
update(w[u], sum[u]-d[u], 1, 1, z);
}
//printf("%d %d  %d \n", u, sum[u], d[u]);
}

void solve()
{
CLR(tree);
dfn = 1;
an = 0;
dfs_dfn(1, 0);
initail();
getEdge();
dep[1] = 0;
dfs_1(1, 0);
z = 0;
dfs_2(1, 0, 1);
dfs(1, 0);
printf("%d\n", d[1]);
}

int main()
{
//freopen("6Fin.txt", "r", stdin);
//freopen("6Fout.txt", "w", stdout);
getP2();
getL2();
int t;
scanf("%d", &t);
while(t--)
{
scanf("%d%d", &n, &edge_n);
REP_D(i, 1, n)
{
G[i].clear();
}
REP_D(i, 1, n-1)
{
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
solve();
}
return 0;
}