给大家介绍一篇写得很好的博客
【题目描述】
给定一棵n个点的树，点带点权。
有m次操作，每次操作给定x,y，表示修改点x的权值为y。
你需要在每次操作之后求出这棵树的最大权独立集的权值大小。
1<=n,m<=10^5
这一道题，其实就是在没有直接上司的舞会这一题中加上一个修改操作，难度也从一个普通的黄题直接升到黑题
如果是像原来那样的暴力，在树退化到链以后会被卡到O(N^2)
再想想，有什么树形结构每次修改+查找仅有log级的复杂度呢
如果是动态树的话，总时间复杂度是O(NlogN)，但是常数过大
然后就是树链剖分了。
先看一下最传统的dp公式
设
f
[
u
]
[
0
]
f[u][0]
f[u][0]表示i不放的最大值，
f
[
i
]
[
1
]
f[i][1]
f[i][1]表示i放的最大值
很容易的出结论（其中G是u儿子的集合）
f
[
u
]
[
0
]
=
∑
v
∈
G
m
a
x
(
f
[
v
]
[
0
]
,
f
[
v
]
[
1
]
)
f[u][0]=\sum_{v∈G}max(f[v][0],f[v][1])
f[u][0]=∑v∈Gmax(f[v][0],f[v][1])
f
[
u
]
[
1
]
=
∑
v
∈
G
f
[
v
]
[
0
]
f[u][1]=\sum_{v∈G}f[v][0]
f[u][1]=∑v∈Gf[v][0]
这样就很难受了，因为每当一个f改变，必定会影响到他的父亲，导致腰一个个的改，所以不能直接在线段树上进行修改
那这要怎么办呢？
经过思考，可以想到，每一个f的改变（先不管重链头），仅仅只是影响到他所在的重链，并没有这条重链周边的重链
所以我们尝试将f分成连个部分分别是所在的重链和周边的重链
设
g
[
u
]
[
0
]
g[u][0]
g[u][0]表示除去重儿子的部分i不放的最大值
g
[
u
]
[
1
]
g[u][1]
g[u][1]表示除去重儿子的部分i放的最大值
那么f的转移方程可以改变为
f
[
u
]
[
0
]
=
g
[
u
]
[
0
]
+
m
a
x
(
f
[
s
o
n
[
u
]
]
[
0
]
,
f
[
s
o
n
[
u
]
]
[
1
]
)
f[u][0]=g[u][0]+max(f[son[u]][0],f[son[u]][1])
f[u][0]=g[u][0]+max(f[son[u]][0],f[son[u]][1])
f
[
u
]
[
1
]
=
g
[
u
]
[
1
]
+
f
[
s
o
n
[
u
]
]
[
0
]
f[u][1]=g[u][1]+f[son[u]][0]
f[u][1]=g[u][1]+f[son[u]][0]
可这样还不行啊，怎么办？
于是就有某位大佬将矩阵乘法改写到可以维护f
原来的矩阵乘法是这样的：
C
[
i
]
[
j
]
=
∑
k
=
1
n
A
[
i
]
[
k
]
∗
B
[
k
]
[
j
]
C[i][j]=\sum\limits_{k=1}^{n}A[i][k]*B[k][j]
C[i][j]=k=1∑nA[i][k]∗B[k][j]
而修改完以后的矩阵乘法就变成了
C
[
i
]
[
j
]
=
max
k
=
1
n
(
A
[
i
]
[
k
]
+
B
[
k
]
[
j
]
)
C[i][j]=\max\limits_{k=1}^{n}(A[i][k]+B[k][j])
C[i][j]=k=1maxn(A[i][k]+B[k][j])
原来的求和变成求最大值，原来的乘法变成了加法
这样以后，我们可以构造矩阵
[
g
[
i
]
[
0
]
g
[
i
]
[
0
]
g
[
i
]
[
1
]
0
]
∗
[
f
[
s
o
n
[
i
]
]
[
0
]
f
[
s
o
n
[
i
]
]
[
1
]
]
=
[
f
[
i
]
[
0
]
f
[
i
]
[
1
]
]
\begin{bmatrix} g[i][0]&g[i][0]\\ g[i][1]&0 \end{bmatrix} * \begin{bmatrix} f[son[i]][0]\\ f[son[i]][1] \end{bmatrix}=\begin{bmatrix} f[i][0]\\ f[i][1] \end{bmatrix}
[g[i][0]g[i][1]g[i][0]0]∗[f[son[i]][0]f[son[i]][1]]=[f[i][0]f[i][1]]
大家可以自己验证一下~~
说道这里，大家或许还是懵的，就像我当时一样
那么我们可以继续将这个式子分解，变为
[
g
[
i
]
[
0
]
g
[
i
]
[
0
]
g
[
i
]
[
1
]
0
]
∗
[
g
[
s
o
n
[
i
]
]
[
0
]
g
[
s
o
n
[
i
]
]
[
0
]
g
[
s
o
n
[
i
]
]
[
1
]
0
]
∗
[
f
[
s
o
n
[
s
o
n
[
i
]
]
]
[
0
]
f
[
s
o
n
[
s
o
n
[
i
]
]
]
[
1
]
]
=
[
f
[
i
]
[
0
]
f
[
i
]
[
1
]
]
\begin{bmatrix} g[i][0]&g[i][0]\\ g[i][1]&0 \end{bmatrix} * \begin{bmatrix} g[son[i]][0]&g[son[i]][0]\\ g[son[i]][1]&0 \end{bmatrix} * \begin{bmatrix} f[son[son[i]]][0]\\ f[son[son[i]]][1] \end{bmatrix}=\begin{bmatrix} f[i][0]\\ f[i][1] \end{bmatrix}
[g[i][0]g[i][1]g[i][0]0]∗[g[son[i]][0]g[son[i]][1]g[son[i]][0]0]∗[f[son[son[i]]][0]f[son[son[i]]][1]]=[f[i][0]f[i][1]]
如果是这样的话，大家应该明白了
这样一直往下分，就可以直达叶子节点
所以在同一条重链中，我们可以用O(logN)的时间求出top的值
像这样一直到根节点，每次就是
O
(
l
o
g
2
n
)
O(log^2 n)
O(log2n)
总结一下，我们用树剖，线段树上每一个节点都构造一个矩阵，记录矩阵之积
不过要注意的是，每次修改到一条重链的头，都会影响到下一条重链，所以记得修改
参考代码
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<queue>
#define il inline
#define dg isdigit
#define gc getchar()
using namespace std;
il int read(){
int x=0,f=0;char s=gc;
while(!dg(s))f|=s=='-',s=gc;
while( dg(s))x=x*10+s-48,s=gc;
return f?-x:x;
}
const int N=1e5+10;
int n,m,a[N];
struct edge{
int v,nxt;
}e[N<<1];int ecnt,last[N];
il void add(int u,int v){
e[++ecnt]=(edge){v,last[u]};
e[++ecnt]=(edge){u,last[v]};
last[u]=ecnt-1,last[v]=ecnt;
}
int fa[N],son[N],size[N],top[N];
int z,idx[N],pos[N],ed[N];
int f[N][2];
struct matrix{//矩阵乘法
int g[2][2];
matrix(){
memset(g,0,sizeof(g));
}
matrix operator*(const matrix &b)const{
matrix c;int i,j,k;//重载"*"运算符
for(i=0;i<2;i++)
for(j=0;j<2;j++)
for(k=0;k<2;k++)
c.g[i][j]=max(c.g[i][j],g[i][k]+b.g[k][j]);
return c;
}
}val[N],tr[N<<2];//val记录每一个点的信息，tr记录线段树上节点的信息
int q[N],l,r;
void init(){//这里本来可以用三个dfs，不过听说这样会更快，而且代码更短
int u,v,i;
for(q[1]=1,l=1,r=1;l<=r;l++)//按深度给每一个点排序，并且将这些点放入q
for(u=q[l],i=last[u];i;i=e[i].nxt)
if((v=e[i].v)!=fa[u])
fa[v]=u,q[++r]=v;
for(r=n;r;r--){//记录子树和重儿子
size[u=q[r]]++;
size[fa[u]]+=size[u];
if(size[u]>size[son[fa[u]]])
son[fa[u]]=u;
}
for(l=1;l<=n;l++)//制造重链
if(!top[u=q[l]]){
for(v=u;v;v=son[v])
top[v]=u,idx[pos[v]=++z]=v;
ed[u]=z;
}
for(r=n;r;r--){//求出f的值
u=q[r];f[u][1]=a[u];
for(i=last[u];i;i=e[i].nxt)
if((v=e[i].v)!=fa[u]){
f[u][0]+=max(f[v][0],f[v][1]);
f[u][1]+=f[v][0];
}
}
}
void build(int now,int l,int r){//构造线段树
if(l==r){
//注意一下，这里now仅仅指的是线段树上的叶子节点
//在真是的树上他并不一定是叶子节点
int g0=0,g1=a[idx[l]];
int i,u=idx[l],v;//求出g
for(i=last[u];i;i=e[i].nxt)
if((v=e[i].v)!=fa[u]&&v!=son[u])
g0+=max(f[v][0],f[v][1]),g1+=f[v][0];
tr[now].g[0][0]=tr[now].g[0][1]=g0;//构造矩阵
tr[now].g[1][0]=g1;val[l]=tr[now];
return ;
}
int mid=(l+r)>>1;
build(now<<1,l,mid);
build(now<<1|1,mid+1,r);
tr[now]=tr[now<<1]*tr[now<<1|1];//维护
}
void change(int now,int l,int r,int p){//修改操作
if(l==r){tr[now]=val[l];return ;}
int mid=(l+r)>>1;
if(p<=mid)change(now<<1,l,mid,p);
else change(now<<1|1,mid+1,r,p);
tr[now]=tr[now<<1]*tr[now<<1|1];
}
matrix query(int now,int l,int r,int x,int y){//查询操作
if(x<=l&&r<=y)return tr[now];
int mid=(l+r)>>1;
if(y<=mid)return query(now<<1,l,mid,x,y);
if(mid<x)return query(now<<1|1,mid+1,r,x,y);
return query(now<<1,l,mid,x,y)*query(now<<1|1,mid+1,r,x,y);
}
matrix ask(int u){//询问
return query(1,1,n,pos[top[u]],ed[top[u]]);
}
il void solve(int u,int x){
val[pos[u]].g[1][0]+=x-a[u];//先修改节点u
a[u]=x;matrix od,nw;
//因为会影响到下一条重链
//所以我们要记录原来重链头和更新以后的重链头
while(u){
od=ask(top[u]);//记录原来的
change(1,1,n,pos[u]);//更新
nw=ask(top[u]);//记录现在的
u=fa[top[u]];//跳到下一条重链上
//重新构造矩阵
val[pos[u]].g[0][0]+=max(nw.g[0][0],nw.g[1][0])
-max(od.g[0][0],od.g[1][0]);
val[pos[u]].g[0][1]=val[pos[u]].g[0][0];
val[pos[u]].g[1][0]+=nw.g[0][0]-od.g[0][0];
}
}
int main(){
n=read(),m=read();
int i,u,v,x;
for(i=1;i<=n;i++)
a[i]=read();
for(i=1;i<n;i++)
u=read(),v=read(),add(u,v);
init();build(1,1,n);matrix t;
while(m--){
u=read(),x=read();
solve(u,x);t=ask(1);
printf("%d\n",max(t.g[0][0],t.g[1][0]));
}
return 0;
}
1766
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
