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
</pre>

输出样例#1：
13

典型的树型dp
令dp[i][j]表示根节点为i的子树选j门课所能修得的最大学分
这样就需要枚举每个儿子的分配数，还要择优，非常麻烦，所以不妨将这颗多叉树转为二叉树便于转改转移的实现
则转二叉之后的状态转移方程为
dp[i][j]=max(dp[ir][j],dp[il][k-1]+dp[ir][j-k]+1);
解释一下就是只选右节点，因为右节点是兄弟所以不选根节点也可以，然后就是选根节点的情况来枚举中间变量k分配给左右节点ir是右il是左；

状态转移的时候可以写记忆化搜索但担心爆栈所以我将节点根据深度排序从下往上for循环

讲得很清楚了下面上代码吧！！

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,v[310],dp[310][310];
struct Node{
    vector<int> son;
}N[310];
struct Node2{
    int r,l,p,deep;
}N2[310];
void change(int t){//多叉转二叉 
    for(int i=0;i<N[t].son.size();i++){
        if(!N2[t].l) N2[t].l=N[t].son[i];
        else{
            int step=N2[t].l;
            while(1){
                if(!N2[step].r){
                    N2[step].r=N[t].son[i];
                    break;
                }
                step=N2[step].r;
            }
        }
        change(N[t].son[i]);
    }
    return;
}
void BFS(int u){//求深度 
    queue<int> q,q1;
    q.push(u);
    q1.push(1);
    while(!q.empty()){
        int x=q.front(),d=q1.front();
        q.pop();
        q1.pop();
        N2[x].deep=d;
        if(N2[x].l){
            q.push(N2[x].l);
            q1.push(d+1);
        }
        if(N2[x].r){
            q.push(N2[x].r);
            q1.push(d+1);
        }
    }
    return;
}
bool cmp(Node2 a, Node2 b){
    return a.deep>b.deep;
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        int ki,si;
        cin>>ki>>si;
        if(!ki) N[n+1].son.push_back(i);
        else N[ki].son.push_back(i);
        v[i]=si;    
    }
    change(n+1);
    for(int i=1;i<=n+1;i++) N2[i].p=i;
    BFS(n+1);
    sort(N2+1,N2+2+n,cmp);
    for(int i=1;i<=n+1;i++) for(int j=1;j<=m;j++) if(!N2[i].l&&!N2[i].r) dp[N2[i].p][j]=v[N2[i].p];
    for(int i=1;i<=n+1;i++){
        if(!N2[i].l&&!N2[i].r) continue;
        for(int j=1;j<=(i==n+1?m+1:m);j++){
            int maxn=-1;
            for(int k=1;k<=j;k++) maxn=max(maxn,dp[N2[i].l][k-1]+dp[N2[i].r][j-k]+v[N2[i].p]);  
            dp[N2[i].p][j]=max(maxn,max(dp[N2[i].r][j],dp[N2[i].l][j-1]+v[N2[i].p]));
        }
    }
    int ans=-1;
    for(int i=1;i<=m+1;i++) ans=ans>dp[n+1][i]?ans:dp[n+1][i];
    cout<<ans<<endl;
    return 0;
}

谢谢！！