树形dp专题总结

大力dp的练习与晋升

原题均可以在网址上找到

技巧总结

1.换根大法

2.状态定义应只考虑考虑影响的关系

3.数据结构与dp的合理结合(T11)

4.抽直径解决求最长链的许多类问题(T12)

5.dp题最基本的考察是对题意模型的转化,以应用在各个方面

6.前缀和等技巧优化dp

7.树形背包是n*n的!

T1 BZOJ1304 [CQOI2009]叶子的染色

首先是对于固定根节点的\(dp\)

\(dp\)状态\(dp[3]\)为子树还需要颜色\(1,2\),或不需要

转移比较简单,关键在于根节点不固定

int dp[N][4],t[N];//0无,1,2
void dfs(int u,int f){
if(u<=m) return;
dp[u][0]=dp[u][1]=dp[u][2]=0;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs(v,u);
dp[u][0]+=min(dp[v][0],dp[v][2]);
dp[u][1]+=min(dp[v][1],dp[v][2]);
dp[u][2]+=dp[v][2];
}
dp[u][2]=min(dp[u][2],min(dp[u][0],dp[u][1])+1);
}

这一点,我们可以两遍\(dfs\)换根,但是网上的神仙们都有证明不同根节点都不会影响答案,->传送门

事实上,在bzoj上直接\(n^2\)也能过。。。

\[\
\]

T2 BZOJ 4726 POI2017 Sabota

关键点捕捉->叛徒一定在叶子上,最后一定是一整颗子树变成叛徒,所以dp每一颗子树成为叛徒的最值即可

(放心不会炸精度)

double k,ans=0;

double dp[N];
int sz[N];
void dfs(int u,int f){
sz[u]=1;
dp[u]=0;
int son=0;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs(v,u);
sz[u]+=sz[v];
son++;
}
if(!son) dp[u]=1;
else {
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dp[u]=max(dp[u],min(dp[v],1.0*sz[v]/(sz[u]-1)));
son++;
}
}
//cout<<u<<' '<<dp[u]<<endl;
if(sz[u]>m) ans=max(ans,dp[u]);
} int main() {
n=rd(),m=rd();
rep(i,2,n) {
int u=i,v=rd();
AddEdge(u,v);
AddEdge(v,u);
}
dfs(1,0);
printf("%.7lf\n",ans);
}

T3 BZOJ3743 [Coci2015]Kamp

其实这是一道很标准的换根求距离

在这张图中,计算根到所有红色节点的方案

先假设最后还回到根,则会遍历每一条红色的边两次,而事实上最后我们可以停在一个节点上

所以取一个最远的红点停下来就好了


ll dp[N],ma[N][4],g[N];
//dp -> 所有红色边的和
//ma -> 最远的红点
void dfs1(int u,int f){
sz[u]=mk[u];
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs1(v,u);
if(sz[v]) {
dp[u]+=dp[v]+e[i].w*2;
ma[u][3]=ma[v][0]+e[i].w;
sort(ma[u],ma[u]+4,greater<ll>());
}
sz[u]+=sz[v];
}
} void dfs2(int u,int f,int ew,ll w){
g[u]=dp[u];
if(f) {
if(sz[u]<m) {
g[u]+=g[f]+ew*2;
if(sz[u]) g[u]-=dp[u]+2*ew;
}
}
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
ll t=w;
if(sz[v]&&ma[u][0]==ma[v][0]+e[i].w)t=max(t,ma[u][1]);
else t=max(t,ma[u][0]);
dfs2(v,u,e[i].w,t+e[i].w);
}
ma[u][3]=w;
sort(ma[u],ma[u]+4,greater<ll>());
}

\[\
\]

\[\
\]

T4 [BZOJ4007] [JLOI2015]战争调度

这题的复杂度非常暴力

\(dp[i][j][k]\)表示当前到第i个叶子节点,共选了j个点,它的祖先就业情况为k

对于\(i\)与\(i+1\)的叶子结点,他们有一段公共的祖先必须相同,其它的可以任意取,所以可以枚举相同的,再枚举不同的,将复杂度降到\(2^{(3n-3)}\)

int dp[2][N][N];
int a[2][N<<1][10],s[2][N<<1][N];
int Log[N<<1]; int main() {
rep(i,2,(1<<10)) Log[i]=Log[i>>1]+1;
n=rd(),t=n-1,m=rd();
rep(i,(1<<t),(1<<n)-1) rep(j,0,t-1) a[1][i][j]=rd();
int cur=0,A=(1<<t)-1;
rep(i,(1<<t),(1<<n)-1) {
rep(j,0,t-1) a[0][i][j]=rd();
rep(j,0,A) {
rep(k,0,t-1) if(j&(1<<k)) s[1][i][j]+=a[1][i][k];
else s[0][i][j]+=a[0][i][k];
}
}
rep(i,(1<<t),(1<<n)-1) {
cur^=1;
if(i==(1<<t)) {
rep(j,0,A) {
dp[cur][j][0]=s[0][i][j];
dp[cur][j][1]=s[1][i][j];
}
} else {
int my=Log[i&-i],his=t-my;//lowbit即LCA
rep(d,0,m) {
rep(j,0,(1<<his)-1) {//枚举公共部分
int ma1=0,ma2=0;
rep(k,0,(1<<my)-1) {//枚举上一位选了什么
chk(ma1,dp[!cur][(j<<my)|k][d]);
if(d) chk(ma2,dp[!cur][(j<<my)|k][d-1]);
}
rep(k,0,(1<<my)-1) {//转移这一位选了什么
dp[cur][(j<<my)|k][d]=ma1+s[0][i][(j<<my)|k];
if(d) {
chk(dp[cur][(j<<my)|k][d],ma2+s[1][i][(j<<my)|k]);
}
}
}
}
}
}
int ans=0;
rep(i,0,A) rep(j,0,m) chk(ans,dp[cur][i][j]);
printf("%d\n",ans);
}

\[\
\]

\[\
\]

T5 4238电压

其实是一个二分图染色问题,并不是树形dp

一个二分图成立的条件即不存在奇环

但是在这题的限制条件下,断开偶环同样不成立,因为根本断不开。。。电流依然存在

所以就是求所有的边能覆盖所有的奇环,并且不被任意一个偶环覆盖

这个东西其实树上差分就能搞定,是我写麻烦了

int n,t,m;

struct Edge{
int to,nxt,id;
}e[N<<1];
int head[N],ecnt;
void AddEdge(int u,int v,int id) {
e[++ecnt]=(Edge){v,head[u],id};
head[u]=ecnt;
}
#define erep(u,i) for(int i=head[u];i;i=e[i].nxt) int eu[N],ev[N];
int vis[N],intree[N],fa[N];
int sz[N],son[N],top[N],dep[N]; int ans,cnt; void dfs1(int u,int f){
vis[u]=1;
sz[u]=1,fa[u]=f;
erep(u,i) {
int v=e[i].to;
if(vis[v]) continue;
intree[e[i].id]=1;
dep[v]=dep[u]+1;
dfs1(v,u);
sz[u]+=sz[v];
if(sz[son[u]]<sz[v]) son[u]=v;
}
} int L[N],R[N],dfn,id[N];
int s[N]; void dfs2(int u,int t){
id[L[u]=++dfn]=u;
top[u]=t;
if(son[u]) dfs2(son[u],t);
erep(u,i) {
int v=e[i].to;
if(v==son[u]||v==fa[u]||!intree[e[i].id]) continue;
dfs2(v,v);
}
R[u]=dfn;
} int sum[N];
int LCA(int x,int y){
while(top[x]!=top[y]) {
if(dep[top[x]]<dep[top[y]]) swap(x,y);
x=fa[top[x]];
}
if(dep[x]<dep[y]) swap(x,y);
return y;
} void Up(int x,int y){
int lca=LCA(x,y),len=dep[x]+dep[y]-dep[lca]*2+1;
if(len&1) {
ans=len;
cnt++;
while(top[x]!=top[y]) {
if(dep[top[x]]<dep[top[y]]) swap(x,y);
sum[L[top[x]]]++,sum[L[x]+1]--;
x=fa[top[x]];
}
if(dep[x]<dep[y]) swap(x,y);
if(x!=y) sum[L[y]+1]++,sum[L[x]+1]--;
return;
}
while(top[x]!=top[y]) {
if(dep[top[x]]<dep[top[y]]) swap(x,y);
s[L[top[x]]]++,s[L[x]+1]--;
x=fa[top[x]];
}
if(dep[x]<dep[y]) swap(x,y);
if(x!=y) s[L[y]+1]++,s[L[x]+1]--;
} int rt[N],c; int main() {
n=rd(),m=rd();
rep(i,1,m) {
eu[i]=rd(),ev[i]=rd();
AddEdge(eu[i],ev[i],i);
AddEdge(ev[i],eu[i],i);
}
rep(i,1,n) if(!vis[i]) dfs1(rt[++c]=i,0);
rep(i,1,c) dfs2(rt[i],1);
rep(i,1,m) if(!intree[i]) Up(eu[i],ev[i]);
rep(i,1,n) s[i]+=s[i-1];
rep(i,1,c) s[L[rt[i]]]=1;
if(cnt) {
rep(i,1,n) sum[i]+=sum[i-1];
ans=0;
rep(i,1,n) if(sum[i]==cnt&&!s[i]) ans++;
if(cnt==1) ans++; //cnt=1时,可以断树外的那条边
return printf("%d\n",ans),0;
}
rep(i,1,n) if(!s[i]) ans++;
printf("%d\n",ans);
}

\[\
\]

\[\
\]

T6 [BZOJ1509] [NOI2003]逃学的小孩]

题意可能会有点绕,好好理解一下

在这张图中,我们枚举黑点为三个点路径的交点

则最优的三个点一定是途中红色路径所到达的三个点

即树内两条最长链,树外一条最长链

接下来你可以直接枚举\(A,B,C\)的位置,但是其实可以发现,三条链中最多只有一条会被遍历两次,而两次不会出现在最长边上,所以我们让次长边被遍历两边即可

struct Node{
ll a[4];
void operator += (const int x) {
a[3]=x;
sort(a,a+4,greater<ll>());
}
}g[N]; ll ans; void dfs1(int u,int f){
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs1(v,u);
g[u]+=g[v].a[0]+e[i].w;
}
} void dfs2(int u,int f,ll w) {
ll t[5];
rep(i,0,2) t[i]=g[u].a[i];
t[3]=w;
sort(t,t+4,greater<ll>());
ans=max(ans,t[0]+t[1]*2+t[2]);
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
ll t=w;
if(g[u].a[0]==g[v].a[0]+e[i].w) t=max(t,g[u].a[1]);
else t=max(t,g[u].a[0]);
dfs2(v,u,t+e[i].w);
}
}

\[\
\]

\[\
\]

T7 3696. 化合物

没办法,正解FWT不会,只能写暴力水

int maxdep[N];
void dfs(int u,int f){
maxdep[u]=0;
dp[u][0]++;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs(v,u);
for(reg int j=0;j<=maxdep[u];++j) for(reg int k=0;k<=maxdep[v];++k) cnt[j^(k+1)]+=1ll*dp[u][j]*dp[v][k];
rep(j,0,maxdep[v]) dp[u][j+1]+=dp[v][j];
maxdep[u]=max(maxdep[u],maxdep[v]+1);
}
}

\[\
\]

\[\
\]

T8 BZOJ4824 [Cqoi2017]老C的键盘

这题主要是要想到dp状态,转移其实并不难,并且这道题和 T10 [[BZOJ3167][Heoi2013]Sao] 一样

dp状态:

\(dp[i][j]\)表示第\(i\)棵子树, \(i\)号节点在子树中排名为\(j\)的方案数, 因为只用考虑相邻节点大小的关系,所以可以比较简单的转移

若确定在已经合并的总子树中,当前节点为\(u\),将要被合并上来的节点为\(v\) , \(v\) 的子树中贡献了\(j\)个权值小于\(u\)的点,并且\(v\)小于\(u\)

则有\(dp[u][i+j]=dp[u][i]*dp[v][1..j]*C(i-1+j,j)*C(sz[u]-i+sz[v]-j,sz[v]-j)\)

即确定\(i\),\(j\)关系,将小于\(u\)的和大于\(u\)的合并点可以分别任意排列大小,是一个简单的树形背包

关于这个组合数,我的代码里写的不一样,其实也可以这样理解

设\(k\)个子树里传进\(c[1..k]\)个小于\(u\)的数

那么我们先假设将这些所有的数排列,总共的方案即\((\sum_{i=1}^{i \leq k} \ c[i])!\)

然而子树里的排布顺序其实已经固定,所以还要分别除掉Meiz每一棵子树里的排布方案,即\(\Pi_{i=1}^{i \leq k} \ c[i]!\)

发现对于转移最后得到的所有\(dp[u][i]\),总方案为\(i!\),所以只要在转移时乘上逆元即可

由于要访问\(dp[v][1..j]\),所以还要前缀和一下

大于号就是反过来

ll po[N]={1,1},Inv[N]={1,1};
ll dp[N][N],tmp[N];
int sz[N];
void dfs(int u,int f){
memset(dp[u],0,sizeof dp[u]);
sz[u]=dp[u][1]=1;
erep(u,t) {
int v=e[t].to,w=e[t].w;
if(v==f) continue;
dfs(v,u);
memset(tmp,0,sizeof tmp);
if(w) {
rep(i,1,sz[v]) (dp[v][i]+=dp[v][i-1])%=P;
rep(i,1,sz[u]) {
rep(j,1,sz[v]) {
(tmp[i+j]+=Inv[j]*Inv[sz[v]-j]%P*dp[u][i]%P*dp[v][j]%P)%=P;
}
}
} else {
drep(i,sz[v],1) (dp[v][i]+=dp[v][i+1])%=P;
rep(i,1,sz[u]) {
rep(j,1,sz[v]) {
(tmp[i+j-1]+=Inv[j-1]*Inv[sz[v]-j+1]%P*dp[u][i]%P*dp[v][j]%P)%=P;
}
}
}
sz[u]+=sz[v];
rep(i,1,sz[u]) dp[u][i]=tmp[i];
}
rep(i,1,sz[u]) dp[u][i]=dp[u][i]*po[i-1]%P*po[sz[u]-i]%P;
} void _main(){
n=rd();
rep(i,1,n) head[i]=0;ecnt=0;
rep(i,2,n) {
int u=rd()+1,t=getchar(),v=rd()+1;
if(t=='<') t=0;
else t=1;
AddEdge(u,v,t);
AddEdge(v,u,!t);
}
dfs(1,0);
ll ans=0;
rep(i,1,n) ans+=dp[1][i];
ans%=P;
printf("%lld\n",ans);
} int main(){
rep(i,2,N-1) {
po[i]=po[i-1]*i%P;
Inv[i]=(P-P/i)*Inv[P%i]%P;
}
rep(i,1,N-1) Inv[i]=Inv[i-1]*Inv[i]%P;
rep(kase,1,rd()) _main();
}

\[\
\]

\[\
\]

T9 [BZOJ1808][IOI2007]training 训练路径]

整个题的模型其实比较好想,关键是最后这个dp转移的实现

题意即给出了树边和非树边,要求去掉一些非树边使得图上没有偶环

对于偶环:当然全部去掉啊!

对于奇环:若两个奇环在树上的覆盖区域(是一个树边的连续路径)有重叠,则它们可以构成偶环,依然要去掉一部分

难点在于重叠部分dp难以转移 (好像可以二分图最大权值匹配)

肯定是要把环挂在\(LCA\)上处理

定义状态\(dp[u]\)为选择整个环在\(u\)的子树里的环最大能保留的权值

环的点可以重叠,但边不行,所以每一个点的每一个儿子都最多只会被一个奇环覆盖

而一个奇环最多覆盖两个节点,所以定义辅助\(tmp[u][S]\)表示\(u\)的子树里儿子被覆盖的状态为\(S\)

这里关于覆盖我的写法里还有一种覆盖-->:直接把儿子的\(dp[son]\)转移过来

当你在\(u\)处转移到一个环两个端点为\(x,y\)时,它的贡献不止是环的权值,还有两个儿子里没有被影响到的\(dp\)值总和

这个东西我们用一个数组\(g[u][v]\)存下来,每次都遍历一遍预处理出来

如何预处理?每遍历一个儿子就累和\(tmp[u][S - (1<<sonid)]\),就去掉了被影响部分的答案

还有就是\(tmp[u][S]\)要进行子集累最大值

int n,m;

struct Edge{
int to,nxt;
}e[N<<1];
int head[N],ecnt;
void AddEdge(int u,int v) {
e[++ecnt]=(Edge){v,head[u]};
head[u]=ecnt;
}
#define erep(u,i) for(int i=head[u];i;i=e[i].nxt) int fa[N][14],dep[N];
void pre_dfs(int u,int f){
fa[u][0]=f;
for(int i=1;(1<<i)<=dep[u];++i) fa[u][i]=fa[fa[u][i-1]][i-1];
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dep[v]=dep[u]+1;
pre_dfs(v,u);
}
} int Up(int x,int k) {
for(int i=0;(1<<i)<=k;++i) if(k&(1<<i)) x=fa[x][i];
return x;
}
int LCA(int x,int y){
if(dep[x]<dep[y]) swap(x,y);
x=Up(x,dep[x]-dep[y]);
if(x==y) return x;
drep(i,10,0) if(dep[x]>=(1<<i) && fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
return fa[x][0];
} struct node{
int x,y;
};
struct Node{
int c,w;
node a[2];
};
int eu[M],ev[M],ew[M],mm;
vector <Node> G[N]; int dp[N],g[N][N];
int c[M],val[M];
int id[N][N]; int tmp[N][1<<10],son[N];
void dfs_getg(int rt,int u,int f,int w){
g[rt][u]=w;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs_getg(rt,v,u,w+tmp[u][((1<<son[u])-1)^(1<<id[u][v])]);
}
}//处理g数组 void dfs_getdp(int u,int f){
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
dfs_getdp(v,u);
dfs_getg(u,v,u,0);
}
int n=0;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
id[u][v]=n++;
son[u]++;
}
int m=G[u].size();
rep(i,0,m-1) {
c[i]=0;
val[i]=G[u][i].w;
rep(j,0,G[u][i].c-1) val[i]+=g[u][G[u][i].a[j].x]+dp[G[u][i].a[j].x],c[i]|=1<<id[u][G[u][i].a[j].y];
}//处理链的贡献
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
c[m]=1<<id[u][v];
val[m++]=dp[v];
}//儿子直接转移上来
rep(S,0,(1<<n)-1) {
rep(i,0,m-1) {
if(S&c[i]) continue;
tmp[u][S|c[i]]=max(tmp[u][S|c[i]],tmp[u][S]+val[i]);
}
rep(j,0,n-1) if(S&(1<<j)) tmp[u][S]=max(tmp[u][S],tmp[u][S^(1<<j)]);//子集累最大值
dp[u]=max(dp[u],tmp[u][S]);
}//处理tmp数组
} int main(){
n=rd(),m=rd();
rep(i,1,m) {
int u=rd(),v=rd(),w=rd();
if(!w) {
AddEdge(u,v);
AddEdge(v,u);//树边
} else {
eu[++mm]=u;
ev[mm]=v;
ew[mm]=w;//存环
}
}
m=mm;
pre_dfs(1,0);
int sum=0;
rep(i,1,m) {
int x=eu[i],y=ev[i];
sum+=ew[i];
if(dep[x]<dep[y]) swap(x,y);
int lca=LCA(x,y);
if((dep[x]+dep[y]-2*dep[lca])&1) continue;//偶环
Node t;t.c=0,t.w=ew[i];
t.a[t.c++]=(node){x,Up(x,dep[x]-dep[lca]-1)};
if(y!=lca) t.a[t.c++]=(node){y,Up(y,dep[y]-dep[lca]-1)};
G[lca].push_back(t);
}
dfs_getdp(1,0);
printf("%d\n",sum-dp[1]);
}

\[\
\]

\[\
\]

T10 同 T8

\[\
\]

\[\
\]

T11 2164. 采矿

这题难度在于读题和对算法暴力程度的评估...

因为每个点没有互相影响,所以直接线段树存储子树信息,\(m^2\)合并区间的\(dp\)值

对于到根的路径上的点,取每个点权值max即可,树剖线段树

总复杂度\(O(C \cdot N \cdot log \ n \cdot m^2+C \cdot log^2 n \cdot m)\)

int n,m,A,B,Q;
int fa[N];
vector <int> G[N];
template <typename T> void chk(T &a,T b) { ((a<b)&&(a=b)); } int L[N],R[N],id[N],dfn,sz[N],son[N],top[N],dep[N];
void dfs1(int u) {
sz[u]=1;
rep(i,0,G[u].size()-1) {
int v=G[u][i];
dep[v]=dep[u]+1;
dfs1(v);
sz[u]+=sz[v];
if(sz[v]>sz[son[u]]) son[u]=v;
}
}
void dfs2(int u,int t){
id[L[u]=++dfn]=u;
top[u]=t;
if(son[u]) dfs2(son[u],t);
rep(i,0,G[u].size()-1) {
int v=G[u][i];
if(v==son[u]) continue;
dfs2(v,v);
}
R[u]=dfn;
} inline int Get() {
A=(0ll+(A^B)+(B/X)+1ll*B*X)&Y;
B=(0ll+(A^B)+(A/X)+1ll*A*X)&Y;
return (A^B)%Q;
} struct Node{
ll a[51];
void Getline() {
rep(i,1,m) a[i]=Get();
sort(a+1,a+m+1);
}
Node operator + (const Node x) const{
Node res; memset(res.a,0,sizeof res.a);
rep(i,0,m) rep(j,0,m-i) chk(res.a[i+j],a[i]+x.a[j]);
return res;
}
}C[N],dp[N<<2]; void Build(int p,int l,int r){
if(l==r) {
dp[p]=C[id[l]];
return;
}
int mid=(l+r)>>1;
Build(p<<1,l,mid);
Build(p<<1|1,mid+1,r);
dp[p]=dp[p<<1]+dp[p<<1|1];
}
void Upd(int p,int l,int r,int x){
if(l==r) {
dp[p]=C[id[l]];
return;
}
int mid=(l+r)>>1;
if(x<=mid) Upd(p<<1,l,mid,x);
else Upd(p<<1|1,mid+1,r,x);
dp[p]=dp[p<<1]+dp[p<<1|1];
}
Node Que(int p,int l,int r,int ql,int qr) {
if(l==ql&&qr==r) return dp[p];
int mid=(l+r)>>1;
if(qr<=mid) return Que(p<<1,l,mid,ql,qr);
else if(ql>mid) return Que(p<<1|1,mid+1,r,ql,qr);
else return Que(p<<1,l,mid,ql,mid)+Que(p<<1|1,mid+1,r,mid+1,qr);
} struct SGT{
int s[N<<2];
void Build(int k,int p,int l,int r) {
if(l==r) {
s[p]=C[id[l]].a[k];
return;
}
int mid=(l+r)>>1;
Build(k,p<<1,l,mid);
Build(k,p<<1|1,mid+1,r);
s[p]=max(s[p<<1],s[p<<1|1]);
}
void Upd(int p,int l,int r,int x,int y){
if(l==r) {
s[p]=y;
return;
}
int mid=(l+r)>>1;
if(x<=mid) Upd(p<<1,l,mid,x,y);
else Upd(p<<1|1,mid+1,r,x,y);
s[p]=max(s[p<<1],s[p<<1|1]);
}
int Que(int p,int l,int r,int ql,int qr) {
if(l==ql&&r==qr) return s[p];
int mid=(l+r)>>1;
if(qr<=mid) return Que(p<<1,l,mid,ql,qr);
else if(ql>mid) return Que(p<<1|1,mid+1,r,ql,qr);
else return max(Que(p<<1,l,mid,ql,mid),Que(p<<1|1,mid+1,r,mid+1,qr));
}
}tr[51]; int main() {
n=rd(),m=rd(),A=rd(),B=rd(),Q=rd();
rep(i,2,n) G[fa[i]=rd()].push_back((int)i);
dep[1]=1;dfs1(1),dfs2(1,1);
rep(i,1,n) C[i].Getline();
Build(1,1,n);
rep(i,1,m) tr[i].Build(i,1,1,n);
rep(i,1,rd()) {
int opt=rd();
if(opt==0) {
int p=rd();
C[p].Getline();
Upd(1,1,n,L[p]);
rep(i,1,m) tr[i].Upd(1,1,n,L[p],C[p].a[i]);
} else {
int x=rd(),y=rd();
Node res=Que(1,1,n,L[x],R[x]);
ll ans=res.a[m];
int t=fa[x];
if(t&&x!=y) {
while(top[t]!=top[y]) {
rep(j,0,m-1) chk(ans,res.a[j]+tr[m-j].Que(1,1,n,L[top[t]],L[t]));
t=fa[top[t]];
}
rep(j,0,m-1) chk(ans,res.a[j]+tr[m-j].Que(1,1,n,L[y],L[t]));
}
printf("%lld\n",ans);
}
}
}

\[\
\]

\[\
\]

T12 [BZOJ4890] [TJOI2017]城市

\(n^2\)大暴力可水

枚举断开的边,两边要使最小,应是取出两边的直径中点相连,否则两条直径相接的路径会很长

所以就可以暴力了呀


int eu[N],ev[N],ew[N];
int vis[N],fa[N],fe[N],fid[N];
int ma,id;
void dfs(int u,int f,int d){
if(d>ma) ma=d,id=u;
erep(u,i) {
int v=e[i].to;
if(v==f||vis[v]) continue;
fa[v]=u,fe[v]=e[i].w,fid[v]=(i+1)/2+1;
dfs(v,u,d+e[i].w);
}
}
int can[N]; int main(){
n=rd();
rep(i,2,n) {
int u=rd(),v=rd(),w=rd();
AddEdge(u,v,w);
AddEdge(v,u,w);
eu[i]=u,ev[i]=v,ew[i]=w;
}
ma=-1;
dfs(1,0,0);
int rt=id;
ma=-1;
dfs(rt,0,0);
while(id!=rt) {
can[fid[id]]=1;
id=fa[id];
}
int ans=ma;
rep(i,2,n) if(can[i]) {
vis[eu[i]]=1;
ma=-1;
dfs(ev[i],0,0);
int rt=id;
ma=-1;
dfs(rt,0,0);
vis[eu[i]]=0;
int l=ma,mid,rmid;
while(1) {
if(l>=ma/2) mid=l;
if(l<=ma/2) {
rmid=l;
break;
}
l-=fe[id];
id=fa[id];
}
int t=min(max(mid,ma-mid),max(rmid,ma-rmid)),t1=ma; vis[ev[i]]=1;
ma=-1;
dfs(eu[i],0,0);
rt=id;
ma=-1;
dfs(rt,0,0);
vis[ev[i]]=0;
l=ma;
while(1) {
if(l>=ma/2) mid=l;
if(l<=ma/2) {
rmid=l;
break;
}
l-=fe[id];
id=fa[id];
}
int t2=min(max(mid,ma-mid),max(rmid,ma-rmid));
ans=min(ans,max(max(t1,ma),t+t2+ew[i]));
}
printf("%d\n",ans);
}

\(O(n)\)做法

结论1:断开的边一定在直径上,否则答案就是直径

结论2:在直径断开后,两子树里的直径有一端点是直径的端点

将直径拉出来变成一个序列,分别求出前缀和后缀的直径和直径中点即可

从左向右遍历,直径长度必然是单调非递减的,由于直径中点一定在原直径上(因为子树直径中属于原直径的部分一定比不属于的部分长),半径的长度也在单调非递减,所以可以尺取求中点

int fa[N],fe[N],fid[N];
int ma,id;
void dfs(int u,int f,int d){
fa[u]=f;
if(d>ma) ma=d,id=u;
erep(u,i) {
int v=e[i].to;
if(v==f) continue;
fe[v]=e[i].w,fid[v]=(i+1)/2+1;
dfs(v,u,e[i].w+d);
}
}
int line[N],d[N],cnt,mk[N];
int len[N]; void dfs_findchain(int u,int f,int d){
ma=max(ma,d);
erep(u,i) {
int v=e[i].to;
if(mk[v]||v==f) continue;
dfs_findchain(v,u,d+e[i].w);
}
}//子树的直径一定是由 一段原直径 和 一段直径上点非直径子树的链 相连而得的,所以要预处理这个链长 //prefix
int premid[N],prelen[N]; //suffix
int sufmid[N],suflen[N]; int main(){
n=rd();
rep(i,2,n) {
int u=rd(),v=rd(),w=rd();
AddEdge(u,v,w);
AddEdge(v,u,w);
}
ma=-1;
dfs(1,0,0);
int rt=id;
ma=-1;
fa[rt]=0,fe[rt]=0,fid[rt]=0,dfs(rt,0,0);
int ans=ma;
while(id) {
mk[id]=1;
line[++cnt]=id;
id=fa[id];
}
rep(i,1,cnt/2) swap(line[i],line[cnt-i+1]);
rep(i,1,cnt) {
d[i]=fe[line[i]]+d[i-1];
ma=-1;
dfs_findchain(line[i],0,0);
len[i]=ma;
}
int p=1;
rep(i,1,cnt) {
prelen[i]=max(len[i]+d[i],prelen[i-1]);//求出子树直径长度
while(p<i && max(prelen[i]-d[p],d[p])>max(prelen[i]-d[p+1],d[p+1]) ) p++;//尺取中点位置
premid[i]=max(prelen[i]-d[p],d[p]);
}
p=cnt+1;
drep(i,cnt,1) {
suflen[i]=max(suflen[i+1],len[i]+d[cnt]-d[i]);
while(p>i+1 &&
max(suflen[i]-(d[cnt]-d[p-1]),(d[cnt]-d[p-1]))>max(suflen[i]-(d[cnt]-d[p-2]),(d[cnt]-d[p-2]))) p--;
sufmid[i]=max(suflen[i]-(d[cnt]-d[p-1]),(d[cnt]-d[p-1]));
}
rep(i,1,cnt-1)
ans=min(ans,max(max(prelen[i],suflen[i+1]),premid[i]+sufmid[i+1]+d[i+1]-d[i]));
printf("%d\n",ans);
}

\[\
\]

\[\
\]

T13 2616. SPOJ PERIODNI

笛卡尔树构树+树形dp

其实这题并不是真正用到了笛卡尔树,只是用它的一个性质来方便我们的dp

构树后会形成一棵二叉树,树形满足\(h[lson]>h[u] , h[rson]>h[u]\),且\(lson<u<rson\)

观察到这样的构树可以使得\(lson,rson\)的\(h[lson] - (h[u]-1),h[rson]- (h[u]-1)\)部分的dp互不影响,可以直接进行转移,最后我们再拿出来,在$h[u]- (h[fa]-1) $这一段空间里放点即可,建议这个放点的方案自己推一下,应该是一个组合数乘一个排列数

关于构树:我只提供\(n^2\)写法,每次查找区间\(L,R\)里的最小值\(h[mid]\),再递归构建\(l,mid-1\),\(mid+1,r\),线性写法网上有很多

int n,m;
int a[N],dp[N][N],sz[N];
int tmp[N]; int po[M]={1,1},Inv[M]={1,1}; int dfs(int l,int r,int f) {
if(l>r) return 0;
int u,mi=1e9;
rep(i,l,r) if(a[i]<mi) mi=a[i],u=i;
int ls=dfs(l,u-1,u);
int rs=dfs(u+1,r,u);//找儿子
sz[u]=0;
dp[u][0]=1;
if(ls) {
rep(i,0,sz[u]) tmp[i]=dp[u][i],dp[u][i]=0;
rep(i,0,sz[u]) rep(j,0,sz[ls]) dp[u][i+j]=(dp[u][i+j]+1ll*tmp[i]*dp[ls][j]%P)%P;
sz[u]+=sz[ls];
}
if(rs) {
rep(i,0,sz[u]) tmp[i]=dp[u][i],dp[u][i]=0;
rep(i,0,sz[u]) rep(j,0,sz[rs]) dp[u][i+j]=(dp[u][i+j]+1ll*tmp[i]*dp[rs][j]%P)%P;
sz[u]+=sz[rs];
}//合并子树信息
sz[u]++;
int d=a[u]-a[f];
drep(i,sz[u],1) {
drep(j,i-1,max(0,i-d)) {
dp[u][i]=(dp[u][i]+1ll*dp[u][j]*po[sz[u]-j]%P*Inv[i-j]%P*Inv[sz[u]-i]%P*po[d]%P*Inv[d-(i-j)]%P)%P;
}
}//在剩下的空间里放点
return u;
} int main(){
rep(i,2,M-1) {
po[i]=1ll*po[i-1]*i%P;
Inv[i]=1ll*(P-P/i)*Inv[P%i]%P;
}
rep(i,2,M-1) Inv[i]=1ll*Inv[i]*Inv[i-1]%P;
n=rd(),m=rd();
rep(i,1,n) a[i]=rd();
printf("%d\n",dp[dfs(1,n,0)][m]);
}

树形dp专题总结的更多相关文章

  1. 树形DP专题

    DP是我的弱项, 此专题意在总结树形DP的解题思路. 最小代价遍历一棵树 给定一棵带边权的树 $T=(V,E)$ , 遍历它 (树的每个节点都访问至少一次) 所需的最小代价. 这里的代价由具体问题所定 ...

  2. 【DP_树形DP专题】题单总结

    转载自 http://blog.csdn.net/woshi250hua/article/details/7644959#t2 题单:http://vjudge.net/contest/123963# ...

  3. DP专题&#183;四(树形dp)

    1.poj 115 TELE 题意:一个树型网络上有n个结点,1~n-m为信号传送器,n-m+1~n为观众,当信号传送给观众后,观众会付费观看,每铺设一条道路需要一定费用.现在求以1为根,使得收到观众 ...

  4. 动态规划专题(二)——树形DP

    前言 \(DP\)这东西真的是博大精深啊...... 简介 树形\(DP\),顾名思义,就是在树上操作的\(DP\),一般可以用\(f_i\)表示以编号为\(i\)的节点为根的子树中的最优解. 转移的 ...

  5. 【ACM/ICPC2013】树形动态规划专题

    前言:按照计划,昨天应该是完成树形DP7题和二分图.最大流基础专题,但是由于我智商实在拙计,一直在理解树形DP的思想,所以第二个专题只能顺延到今天了.但是昨天把树形DP弄了个5成懂我是很高兴的!下面我 ...

  6. dp专题训练

    ****************************************************************************************** 动态规划 专题训练 ...

  7. 树形$dp$学习笔记

    今天学习了树形\(dp\),一开始浏览各大\(blog\),发现都\(TM\)是题,连个入门的\(blog\)都没有,体验极差.所以我立志要写一篇可以让初学树形\(dp\)的童鞋快速入门. 树形\(d ...

  8. Codeforces1223E. Paint the Tree(树形dp)

    题目链接:传送门 题目大意: 给出节点数为n的一棵带权树,和每个点的最大染色数k.一条边的权重w能产生价值w的条件是,这条边的两端的点至少有一个颜色相同.颜色种类数无限,但每种只能使用两次,问能产生的 ...

  9. poj3417 LCA + 树形dp

    Network Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 4478   Accepted: 1292 Descripti ...

随机推荐

  1. lighttpd为什么要accept多次呢

    在lighttpd网络模型里面我们可以看到以下代码 /* accept()s at most 100 connections directly * * we jump out after 100 to ...

  2. 第二天就跳票 将wikipedia上的英文词条翻译为中文 手动

    忙着改简历一整天,刚说完一天一博,就要跳票了. 还是写点东西吧. 今天又翻译了一个维基百科上的条目,刚过一天就忘了怎么弄,还得回头翻帖子.在这先记一下,省的以后找不到. 1.注册个wiki账号,轻松过 ...

  3. java之redis篇(spring-data-redis整合) (转)

    redis的知识:官网 1,利用spring-data-redis整合 项目使用的pom.xml: <project xmlns="http://maven.apache.org/PO ...

  4. ubuntu Linux 安装和首次使用

    1.ubuntu Linux 安装后切换到root账户,在默认情况下,系统安装过程中需要创建一个用户,切换到root账号命令如下:$ sudo -s -H输入 当前账户密码就可以切换到root.2.u ...

  5. 【poj解题】3664

    简单,两次排序 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 500 ...

  6. 实战项目——mysql主从架构的实现

    一主一从 1.1 环境准备: centos系统服务器2台. 一台用户做Mysql主服务器, 一台用于做Mysql从服务器, 配置好yum源. 防火墙关闭. 各节点时钟服务同步. 各节点之间可以通过主机 ...

  7. 51Nod--1085背包问题

    1085 背包问题 基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题  收藏  关注 在N件物品取出若干件放在容量为W的背包里,每件物品的体积为W1,W2--Wn(Wi为整 ...

  8. Java 并发专题 : Executor具体介绍 打造基于Executor的Webserver

    转载标明出处:http://blog.csdn.net/lmj623565791/article/details/26938985 继续并发,貌似并发的文章非常少有人看啊~哈~ 今天准备具体介绍jav ...

  9. Mac下截屏方法

    Refer to:https://zh.wikihow.com/在Mac-OS-X上截取屏幕截图 先来说几个需要用到的Mac键盘和普通键盘不一样的名字: Mac键盘 普通键盘 control Ctrl ...

  10. 1083 Cantor表

    题目描述 Description 现代数学的著名证明之一是Georg Cantor证明了有理数是可枚举的.他是用下面这一张表来证明这一命题的: 1/1 1/2 1/3 1/4 1/5 … 2/1 2/ ...