树形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 <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <stack>
#include <cstdlib>
#include <queue>
#include <algorithm>
#include <iomanip>
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]<l+r) dp[p][q]=l+r;//DP取最大值 
    }
    dp[p][q]+=tree[p].father;//选它自己的时候需要加上它上面的那根树枝（权值） （这就是为什么不让它等于q的原因了……因为等于了q没办法再选它自己了） 
    return dp[p][q];
}
int main (){
    Init();
    save();
    maketree(1);
    cout<<dfs(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 <iostream>
#include <ctime>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <iomanip>
#include <stack>
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<<max(f[1],g[1]); 
    return 0;
}

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