树形DP的一些理解(一)

树形DP也就是在树上进行动态规划……(比如什么柿子树啊槐树啊苹果树啊)其思路大致为先将问题转化成树 (邻接矩阵、邻接表、链式前向星)(我也不太清楚链式前向星是不是邻接表……总之用就好了)邻接矩阵,方便快捷,简单实用……然后空间占用很大,而邻接表写起来略微繁琐,但是……它空间少啊!!!视情况使用邻接矩阵或者邻接表即可。
开始步入正题……
先来看一下这个二叉苹果树(是的,要在苹果树上做DP)


题目意思:
有一棵苹果树,苹果树的是一棵二叉树,共N个节点,树节点编号为1~N,编号为1的节点为树根,边可理解为树的分枝,每个分支都长着若干个苹果,现在要要求减去若干个分支,保留M个分支,要求这M个分支的苹果数量最多。

输入:
N M
接下来的N-1行是树的边,和该边的苹果数N and M (1 ≤ M < N;1 < N ≤ 100)
输出:
剩余苹果的最大数量。


数据规模也不是很大……但是还是老老实实用邻接表比较好(虽然麻烦,但是可能这个题目给你限制个内存就呵呵了)
我们可以先存一下这个图……我是用的ACdreamers博文中的链式前向星来存的图,有很详细的讲解(传送门:
链式前向星——byACdreamers)
话说ACdreamers有好多篇好的博文……建议大家关注一下。
存好图后,需要把它转成一棵树(因为题目要求要裁掉枝条……自然需要转二叉树)……但是问题是(相比邻接矩阵这种多开了那么大空间的东西)邻接表其实比较晕……
绕的自己晕晕乎乎终于转好了树……转完二叉树我们要做什么呢?自然是DP,看看每个结点选几个枝条即可。
在这里推荐一种方法叫做记忆化搜索!
记忆化搜索是一个搜索+DP的四不像!(四不像是贬义词?)
总之很好用就是了~在找不到很奇怪的转移方程时(阶段划分不明显?),请使用记忆化搜索。(百科了一下……似乎是懒得拓扑排序的时候使用的啊)
PS:————写于刚看懂记忆化搜索20分钟后。
下面来贴一下我的代码。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int maxn=10005;
int n,Q;
int dp[maxn][maxn];
struct star{
    int next,to,w;
}edge[maxn+maxn];   //邻接表无向图边数*2不过据说加法更快 
struct Tree{
    int lc,rc;
    int father;
}tree[maxn+maxn];
int head[maxn+maxn];
int cnt=0;
int vis[maxn];
void Init(){
    memset(head,-1,sizeof(head));
    memset(tree,0,sizeof(tree)); 
    memset(vis,1,sizeof(vis));//没有以这个结点建过树 
    memset(dp,-1,sizeof(dp));//记忆化搜索初值 
    cnt=0;
}
void save(){    //存图
    cin>>n>>Q;
    int u,v,w;
    for(int i=1;i<=n-1;i++){
        scanf("%d%d%d",&u,&v,&w);
        edge[cnt].next=head[u];
        edge[cnt].to=v;
        edge[cnt].w=w;
        head[u]=cnt++;
        edge[cnt].next=head[v];
        edge[cnt].to=u;
        edge[cnt].w=w;
        head[v]=cnt++;
    }
}
void maketree(int root){    //建树 (以root为父亲结点) (话说是不是用father更好啊0v0) 
    vis[root]=0;            //一会要拿它建树,那么先把它弄成0(表示已经建过了) 
    for(int i=head[root];~i;i=edge[i].next){   //开始把链转成树 
        if(vis[edge[i].to]){                     
            if(!tree[root].lc)tree[root].lc=edge[i].to;//不要被这个下标给弄晕(没有左子树) 
            else tree[root].rc=edge[i].to;//右子树 
            tree[edge[i].to].father=edge[i].w;//这里我的father存的是权值(比较奇葩)这个意思是它的子节点与父节点的连线的权值 
            maketree(edge[i].to);//和它相连的结点,开始建树。(也就是它的子树) 
        }
    }
}
int dfs(int p,int q){
    if (~dp[p][q]) return dp[p][q];//如果不再是初值了(已经结算过了) 
    if (p==0 || q==0) //如果已经到了叶节点或者说没有枝条可以再分了 
    {
        dp[p][q]=0; 
        return 0;
    }
    dp[p][q]=0;//已经遍历过了 
    for (int i=0;i<=q-1;i++)//枚举:分几个树枝给左子树分几个给右子树 
    {
        int l=dfs(tree[p].lc,i);//左子树的最优值 
        int r=dfs(tree[p].rc,q-i-1);//右子树的最优值 那么问题来了,为什么这两个(在dfs中第二个参数)相加之和不让它等于q? 
        if (dp[p][q]//DP取最大值 
    }
    dp[p][q]+=tree[p].father;//选它自己的时候需要加上它上面的那根树枝(权值) (这就是为什么不让它等于q的原因了……因为等于了q没办法再选它自己了) 
    return dp[p][q];
}
int main (){
    Init();
    save();
    maketree(1);
    cout<1,Q+1);//Q+1:在DFS中,由于设定的那个枚举是0~q-1,(其中包含了选自己的一根树枝花费),可是根节点不用选自己。 
return 0;
}

感觉非常萌萌哒。(这怎么就萌萌哒了你给我解释)


我是萌萌哒的分割线

上半部分写在NOIP第一次提高组复赛前夜,现在想想确实很不是滋味,虽然第一次参加,但是165分也还是少了点……
继续总结吧。
相信二叉苹果树已经很详细地解答了,下面我们来看一下饭店问题吧。
饭店问题如下:
【题目描述】

政府邀请了你在火车站开饭店,但不允许同时在两个相连接的火车站开。任意两个火车站有且只有一条路径,每个火车站最多有50个和它相连接的火车站。
告诉你每个火车站的利润,问你可以获得的最大利润为多少。

【输入格式】

第一行输入整数N(<=100000),表示有N个火车站,分别用1,2。。。,N来编号。接下来N行,每行一个整数表示每个站点的利润,接下来N-1行描述火车站网络,每行两个整数,表示相连接的两个站点。

【输出格式】

输出一个整数表示可以获得的最大利润。

【样例输入】

6 10
20
25
40
30
30
4 5
1 3
3 4
2 3
6 4
【样例输出】
90
先贴一下带注释的代码吧:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int cnt=0,n;
int head[1005*2];//链式前向星 
int f[1005],g[1005],worth[1005];//f表示选这个点,g表示不选这个点 
struct star{
    int next;
    int to;
}edge[1005*2];
void Init(){//初始化 
    memset(head,-1,sizeof(head));
    memset(f,0,sizeof(f));
    memset(g,0,sizeof(g));
    cnt=0;
}
void save(int u,int v){//链式前向星存图 
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void dfs(int root,int father){//树形DP关键步骤 
    for(int i=head[root];~i;i=edge[i].next){//遍历 
        if(edge[i].to!=father){//如果没有搜索到自己的父节点(也就是判断重复) 
            dfs(edge[i].to,root);//搜索其相邻节点 
            f[root]+=g[edge[i].to];//如果这个点选了那么连接点不选 
            g[root]+=max(f[edge[i].to],g[edge[i].to]);//如果这个点没选,那么可以让连接点选,也可以不选。 
        }
    }
    f[root]+=worth[root];//每个点如果选肯定要加上自己的价值 
}
int main (){
    Init();
    cin>>n;
    for(int i=1;i<=n;i++){
        scanf("%d",&worth[i]);
    }
    int u,v;
    for(int i=1;i<=n-1;i++){
        scanf("%d%d",&u,&v);
        save(u,v);
        save(v,u);
    }
    dfs(1,1);//这里第一个1可以为任意节点,因为你可以选择任何一个点当祖节点……选1最为稳妥。而第二个……可以从负无穷到0,也可以是自己。 
    cout<1],g[1]); 
    return 0;
}

这个注释完毕之后居然愕然发现没有什么可以说的了……
总之,链式前向星的存图与遍历,从上两道题来讲是非常基础的,也是不能手残写错的,比方说我刚刚打这个代码就手残了一下然后调了半天……
至于其它的题肯定是更难(嗯据说这两道题是大水题)
所以打算写完这些之后写一下类似选课的题……
感觉自己理解的还是很浅……

你可能感兴趣的:(动态规划)