树形dp专题总结
时间:2019-09-08
本文章向大家介绍树形dp专题总结，主要包括树形dp专题总结使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
树形dp专题总结
大力dp的练习与晋升
原题均可以在网址上找到
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]);
}
原文地址：https://www.cnblogs.com/chasedeath/p/11485687.html
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法