树形dp

还是很想引用lyd《算法竞赛进阶指南》总的几句话。

 在树上设计动态规划时，一般就以节点从深到浅（子树由大到小）的顺序作为dp的阶段。

在方程中一般第一维是节点编号，代表以该节点为根的子树。

大多数情况下都采用递归的形式实现树形dp。

对于每个节点x，先递归它的每个子节点进行dp，在回溯时，从子节点向节点x进行状态转移。

 

 

 后来翻了翻别人的博客才发现，原来树形dp==套路题，大概就是两个板子倒替用叭QwQ。

两类图：

void dfs(int x)
{
    for(int i=first[x];i;i=next[i])
    {
        int y=to[i];
        if(vis[y])continue;
        dfs(y);
        f[x][0]+=max(f[y][0],f[y][1]);
        f[x][1]+=f[y][0];
    }
}
int main()
{
    int x,y;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>f[i][1];
    for(int i=1;i<=n-1;i++)
    {
        cin>>x>>y;
        add(y,x);
        add(x,y);//注意加两次边，转为无向图 
    }
    dfs(1);//任选一个点作为根进行dp,这里选择1作为根. 
    cout<<max(f[1][1],f[1][0]);
    return 0;
}

void slove(int x)
{
    for(int i=first[x];i;i=next[i])
    {
        int y=to[i];
        slove(y);
        //dp
        f[x][0]+=max(f[y][0],f[y][1]);
        f[x][1]+=f[y][0];
    }
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>f[i][1];//直接读入的时候初始化 
    for(int i=1;i<=n-1;i++)
    {
        cin>>x>>y;
        vis[x]=1;
        add(y,x);
    }
    //找根 
    for(int i=1;i<=n;i++)
        if(!vis[i]){root=i;break;}

    slove(root);
    cout<<max(f[root][1],f[root][0]);//输出答案 
    return 0;
}

tip：

1.无向图建边两次，需要vis判断是否走过

2.有向图需要找根节点

 

两类基本方程：

 

 

选择节点类
dp[i][0]=dp[j][1]
dp[i][1]=max/min(dp[j][0],dp[j][1])

 

树形背包类
dp[v][k]=dp[u][k]+val
dp[u][k]=max(dp[u][k],dp[v][k-1])

 

 例题： 

 

1.没有上司的舞会（选择节点类）

一个n个节点的树，每个点有权值V_i，根节点与子节点不能同时取，求总权值的最大值。

 

#include<iostream>
#include<vector>
using namespace std;
int n,f[7000][3];
int vis[7000],h[7000];
vector<int>son[7000];
void dp(int x)
{
    f[x][1]=h[x];
    f[x][0]=0;
    for(int i=0;i<son[x].size();i++)
    {
        int y=son[x][i];
        dp(y);
        f[x][0]+=max(f[y][1],f[y][0]);
        f[x][1]+=f[y][0];
    }
}
int main()
{
    int x,y;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>h[i];
    while(true)
    {
        cin>>x>>y;//y是x上司 
        if(x==0&&y==0)break;
        vis[x]=1;
        son[y].push_back(x);
    }
    int root;
    for(int i=1;i<=n;i++)
    {
        if(!vis[i])
        {
            root=i;
            break;
        }
    }
    dp(root);
    cout<<max(f[root][1],f[root][0]);
    return 0;
} 

 

来分析这个题的话，dp的第一维表示节点状态，可以用01分别代表不选和选。

f[x,1]表示以x为根的子树，并且x选所能产生的最大值。

f[x,0]表示以x为根的子树，并且x不选的最大值。

很显然的动态转移方程:

f[x,0]=max(f[s,0],f[s,1])(s为x的子节点）

f[x,1]=f[s,0]+h[x]

在进行dfs时，要注意标记节点是否走过，以避免遍历过程中沿着反向边回到父节点。

 

 2.最大子树和最大子树和(选择节点类）

很显然的嘛，父节点选的话子节点可以选可以不选，父节点不选子节点肯定不选，那么动态转移方程就很显然了：

f[x][1]=max(f[son][1],f[son][0])

f[x][0]=0

给出优化（美化）之后的代码：

 

#include<iostream>
#include<stdio.h>
using namespace std;
int dp[20000],n;
int tot=0,first[40000],to[40000],nex[40000],vis[40000];
void add(int x,int y)
{
    tot++;
    nex[tot]=first[x];
    first[x]=tot;
    to[tot]=y;
}
void dfs(int x)
{
    vis[x]=1;
    for(int i=first[x];i;i=nex[i])
    {
        int y=to[i];
        if(vis[y])continue;
        dfs(y);
        dp[x]+=max(0,dp[y]);
    }
}
int main()
{
    int x,y;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>dp[i];
    for(int i=1;i<n;i++)
    {
        cin>>x>>y;
        add(x,y);
        add(y,x);
    }
    dfs(1);
    int ans=0;
    for(int i=1;i<=n;i++)
        ans=max(ans,dp[i]);
    cout<<ans;
    return 0;
}

3.选课（树形背包类）

大概就是在一棵树中，点有点权，选子节点时必须选父节点，但是选父节点可以不选子节点的情况下，产生的权值最大。

就是上面提到的背包类型的树形dp，大众方程：

dp[v][k]=dp[u][k]+val
dp[u][k]=max(dp[u][k],dp[v][k-1])

结合代码看一下叭QwQ：

 

#include<iostream>
using namespace std;
int n,m,tot=0;
int first[1100],to[1100],nex[1100],f[1100][1100];
void add(int x,int y)
{
    tot++;
    nex[tot]=first[x];
    first[x]=tot;
    to[tot]=y;
}
void dp(int x)
{
    for(int i=first[x];i;i=nex[i])
    {
        int y=to[i];
        dp(y);
        for(int j=m+1;j>=1;j--)
            for(int k=0;k<j;k++)
                f[x][j]=max(f[x][j],f[y][k]+f[x][j-k]);
    }
}
int main()
{
    int x,y;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>x>>y;
        add(x,i);
        f[i][1]=y;
    }
    dp(0);
    cout<<f[0][m+1];
    return 0;
}

 

这类问题实际上是背包与树形dp的结合。

F[x,t]表示以x为根的子树中选t门课能获得的最高学分。（就是Gloria意识中的把前i个物品放入容量为j的包里获得的最大价值）

小技巧：一般以第一维态为节点编号，把背包容积作为第二维态，在状态转移时，要处理的实际是分组背包的问题。