树形dp

1.什么是树形动态规划？？？

是不是看不懂？

 这样好点了吧。

常规就是开个二维数组或者结构图或者balablala

记载左右儿子的信息。

 

 来看一道伪树形dp...

P1040 加分二叉树

设一个n个节点的二叉树tree的中序遍历为（1,2,3,…,n），其中数字1,2,3,…,n为节点编号。每个节点都有一个分数（均为正整数），记第i个节点的分数为di,tree及它的每个子树都有一个加分，

任一棵子树subtree（也包含tree本身）的加分计算方法如下：

subtree的左子树的加分× subtree的右子树的加分＋subtree的根的分数。

若某个子树为空，规定其加分为1，叶子的加分就是叶节点本身的分数。不考虑它的空子树。

试求一棵符合中序遍历为（1,2,3,…,n）且加分最高的二叉树tree。要求输出；

（1）tree的最高加分

（2）tree的前序遍历

输入输出格式

输入格式：

第1行：1个整数n(n<30)，为节点个数。

第2行：n个用空格隔开的整数，为每个节点的分数（分数<100）。

输出格式：

第1行：1个整数，为最高加分（Ans ≤4,000,000,000）。

第2行：n个用空格隔开的整数，为该树的前序遍历。

输入输出样例

输入样例#1： 

5
5 7 1 2 10

输出样例#1： 

145
3 1 2 4 5

题意：构造一个最优解的树。这是一个线性dp。所以并不是树形dp..

由于中序遍历下，编号  <  i  的是 i 的左子树，右子树反之。

所以我们三层for

    for(int i=n;i>=1;i--)
        for(int j=i+1;j<=n;j++)
            for(int k=i;k<=j;k++)

做什么呢？

逐一计算答案。判断哪个是根。转移方程很熟悉。

  if(f[i][j]<f[i][k-1]*f[k+1][j]+f[k][k])

　　　　 f[i][j]=f[i][k-1]*f[k+1][j]+f[k][k],rt[i][j]=k; 

因为还要我们输出先序遍历，所以记下root。

这是一道伪树形的水题，直接给代码辽

#include <iostream>
#include <cstdio>
using namespace std;
int n,f[40][40],rt[40][40];
inline void print(int l,int r){
    if(l>r)return ;
    if(l==r){printf("%d ",l);return ;}
    printf("%d ",rt[l][r]);
    print(l,rt[l][r]-1);
    print(rt[l][r]+1,r);
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)cin>>f[i][i],f[i][i-1]=1;
    for(int i=n;i>=1;i--)
        for(int j=i+1;j<=n;j++)
            for(int k=i;k<=j;k++)
                if(f[i][j]<f[i][k-1]*f[k+1][j]+f[k][k])
                    f[i][j]=f[i][k-1]*f[k+1][j]+f[k][k],rt[i][j]=k;
    printf("%d
",f[1][n]);
    print(1,n);
    return 0;                
}

 emmm再看二叉苹果树之前，我们先看一道与之类似的。

想一想怎么表示状态？？

 既然有实现1，那当然有实现2，而且貌似更容易学……

但是为什么要放上来？

因为状态转移方程是类似的。

因为很多细节在这张图片里面。

“f[i][j]表示以第i个节点为根的子树保留j个节点的xxxxx。”很常用，比如等等下面的二叉苹果树。

放一下实现1.

实现2：

别急。看代码之前说明一个问题，这只是部分代码（ppt也没给我全部代码啊。。），看不懂没有关系

笔者建议从下面的二叉苹果树开始看，代码完整，也有题解及我的注释。二叉苹果树我用的是动态数组，这边用的是结构体存边点

然后可以再回头看

把这题提上来讲是因为题目简单明了，两种实现方法的讲解也很适合初学者。至于这实现2也有几种实现方法，比如下一题我就是用了vector。

int dfs(int x,int fa){
    int d=0;//d为该节点的子树的边数
    for(int i=h[x];i;i=e[i].nx){
        int v=e[i].to,w=e[i].w;
        if(v==fa)continue ;
        d+=dfs(v,x)+1;//looook "+1" !!!
        for(int j=min(d,m);j>=1;j--)
            for(int k=min(d,j);k>=1;k--)
                f[x][j]=max(f[x][j],f[x][j-k]+f[v][k-1]+w); 
                //k-1是因为还有儿子自己 w就是儿子自己 这对应实现2的ppt截图会很清楚 
    }
    return d; 
} 

P2015 二叉苹果树

题目描述

有一棵苹果树，如果树枝有分叉，一定是分2叉（就是说没有只有1个儿子的结点）

这棵树共有N个结点（叶子点或者树枝分叉点），编号为1-N,树根编号一定是1。

我们用一根树枝两端连接的结点的编号来描述一根树枝的位置。下面是一颗有4个树枝的树

2   5
  / 
  3   4
    /
    1

现在这颗树枝条太多了，需要剪枝。但是一些树枝上长有苹果。

给定需要保留的树枝数量，求出最多能留住多少苹果。

输入输出格式

输入格式：

第1行2个数，N和Q(1<=Q<= N,1<N<=100)。

N表示树的结点数，Q表示要保留的树枝数量。接下来N-1行描述树枝的信息。

每行3个整数，前两个是它连接的结点的编号。第3个数是这根树枝上苹果的数量。

每根树枝上的苹果不超过30000个。

输出格式：

一个数，最多能留住的苹果的数量。

输入输出样例

输入样例#1： 

5 2
1 3 1
1 4 10
2 3 20
3 5 20

输出样例#1： 

21

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
#define ll long long
#define fo(i,j,k) for(int i=j;i<=k;i++)
using namespace std;
vector <int> f[105],w[105];
int n,m;
int dp[105][105];
inline void dfs(int u,int fa){//当前点，上一个点 
    for(int i=0;i<f[u].size();i++){
        int v=f[u][i],t=w[u][i];//找到和当前点由树枝相连的点 
        if(v==fa)continue ;//不拔起上一个点是吧 
        dfs(v,u);//深搜-- 
    //    f[i][j]表示以第i个节点为根的子树保留j个节点的最大权和。 
        for(int j=m;j;j--)
            fo(k,0,j-1)
                dp[u][j]=max(dp[u][j],dp[u][k]+dp[v][j-k-1]+t);//保留j个，或者k个
        //那么对于左子树保留了k个，右子树保留了j-k-1个（因为当前节点保留，所以-1） 
        //保留？取决于谁留下的苹果多。当然加上当前节点苹果树t 
    }
}
int main(){
    int u,v,d;
    scanf("%d%d",&n,&m);
    fo(i,2,n){
        scanf("%d%d%d",&u,&v,&d);
        f[u].push_back(v);f[v].push_back(u);
        w[u].push_back(d);w[v].push_back(d);
    }    
    dfs(1,0);
    printf("%d
",dp[1][m]);
    return 0;
}

 例子2：

有一棵树，n个节点，规定选了一个点，它相邻的点就不能选。问最多能选多少个点，并判断是否有唯一解？
n<=300。

实现：

 

 第二个问题：多叉树转二叉树

拿一题 选课。

P2014 选课

题目描述

在大学里每个学生，为了达到一定的学分，必须从很多课程里选择一些课程来学习，在课程里有些课程必须在某些课程之前学习，如高等数学总是在其它课程之前学习。现在有N门功课，每门课有个学分，每门课有一门或没有直接先修课（若课程a是课程b的先修课即只有学完了课程a，才能学习课程b）。一个学生要从这些课程里选择M门课程学习，问他能获得的最大学分是多少？

输入输出格式

输入格式：

第一行有两个整数N,M用空格隔开。(1<=N<=300,1<=M<=300)

接下来的N行,第I+1行包含两个整数ki和si, ki表示第I门课的直接先修课，si表示第I门课的学分。若ki=0表示没有直接先修课（1<=ki<=N, 1<=si<=20）。

输出格式：

只有一行，选M门课程的最大得分。

输入输出样例

输入样例#1：

7  4
2  2
0  1
0  4
2  1
7  1
7  6
2  2

输出样例#1：

13

 

图就这样....

多叉树转二叉树后就可以轻松解决了。
定义f[i][j]为i的所有兄弟和i的所有儿子，和i自己，学j门课的最大学分总和。
不学i这门课，全部学兄弟的课程：
f[i][j]=max(f[i][j],f[rson][j])
学i及i的先修课：
f[i][j]=max(f[i][j],f[rson][j-k-1],f[lson][k]+w[i])

emmmm原本按照上面的方法码了一遍莫名其妙bug了

于是一气之下码了背包。

当然是看了9021.

#include <iostream>
using namespace std;
int g[302][302],f[302][302],v[302],m,n,x,y;
inline int dfs(int s){
    int ans=0;
    for(int i=1;i<=m;i++){
        if(g[s][i]){ 
            ans+=dfs(i)+1;
            for(int j=min(ans,m);j;j--)
              for(int k=0;k<j;k++)
                f[s][j]=max(f[s][j],f[s][k]+f[i][j-k-1]+v[i]);
        }
    }
    return ans;
}
int main(){
    cin>>m>>n;
    for(int i=1;i<=m;i++){
        cin>>x>>y;
        g[x][i]=1,v[i]=y;
    }
    dfs(0);
    cout<<f[0][n]<<endl;
}

ans只是要选的课程数 不是总学分。。

皇宫看守（Vijos 1144 小胖守皇宫）

题目思路：

　　【树形DP】

　　F[X][0]表示结点X的父亲放了守卫的最小花费，

　　F[X][1]表示结点X自身放了守卫的最小花费，

　　F[X][2]表示结点X和父亲都不放守卫，X的其中一个儿子放了守卫的最小花费。

　　这样，父亲放了守卫，X可以选择放守卫(F[X][1])，或者可以是 儿子放或不放守卫(F[son][1],F[son][2])

　　自身放守卫，则儿子都是父亲放了守卫(F[son][0])

　　其中一个儿子放了守卫，则枚举哪个儿子是最优值。(F[son][1],F[son][0])

　　这样最终可以推出转移方程。

原文：https://blog.csdn.net/u010568270/article/details/65444860

 改动后代码（其实只是改了码风和一些不必要的东西）：

#include <iostream>
#include <cstdio>
#include <cstring>
#define MAX 0x7fffffff
#define N 1504
#define R register
using namespace std;
int n,m,f[N][3];
bool u[N];
struct xxx{
    int num,c;//儿子数，安置花费 
    int s[N];//儿子编号 
}a[N];
inline int ri(){
    char c=getchar();int x=0,w=1;
    while(!isdigit(c)){if(c=='-')w=-1;c=getchar();}
    while( isdigit(c)){x=(x<<3)+(x<<1)+c-48;c=getchar();}
    return x*w;
}
inline void dp(int now){
    if(u[now])return;
    if(!a[now].num){//根 
        f[now][1] = f[now][2] = a[now].c , f[now][0] = 0;
        return ;
    }
    for(int i=1;i<=a[now].num;i++)
        dp(a[now].s[i]);//搜索每一个儿子 
    f[now][0]=0;
    
    for(int j=1;j<=a[now].num;j++)
        f[now][0]+=min(f[a[now].s[j]][1],f[a[now].s[j]][2]);//已经放了守卫，儿子可放可不放 
    f[now][2]=MAX;
    
    for(int j=1;j<=a[now].num;j++)//不放守卫，则儿子放，孙子可放可不放 
        f[now][2]=min(f[now][2],f[now][0]-min(f[a[now].s[j]][1],f[a[now].s[j]][2])+f[a[now].s[j]][1]);
    f[now][1]=a[now].c;
    
    for(int j=1;j<=a[now].num;j++)
        f[now][1]+=f[a[now].s[j]][0];//自身放守卫，则儿子都是父亲放了守卫(F[son][0]) 
    f[now][0]=min(f[now][0],f[now][1]);
}
int main(){
    int x,y,z;
    while(scanf("%d",&n)){
        for(int i=1;i<=n;i++){
             x=ri(), a[x].c=ri(), a[x].num=ri();
            for(int j=1;j<=a[x].num;j++)
                a[x].s[j]=ri(),u[a[x].s[j]]=1;//记录该节点    
        }
        for(m=1;m<=n;m++) if(!u[m]) break;//找节点最小的 
        memset(u,0,sizeof(u));
        dp(m);
        printf("%d
",min(f[m][1],f[m][2]));
    }
    return 0;
}

（也不知道有没有错）

 ...