世界真的很大
（还是纪念fate）
动态规划的题很常见了
其中背包问题也是屡见不鲜
而有时各个物品间有各种依赖关系，构成一颗树状的结构
有人将其称之为
树形依赖背包动态规划
还是先看一下题：
Description

现在我们的手头有N个软件，对于一个软件i，它要占用Wi的磁盘空间，它的价值为Vi。我们希望从中选择一些软件安装到一台磁盘容量为M计算机上，使得这些软件的价值尽可能大（即Vi的和最大）。
 
但是现在有个问题：软件之间存在依赖关系，即软件i只有在安装了软件j（包括软件j的直接或间接依赖）的情况下才能正确工作（软件i依赖软件j)。幸运的是，一个软件最多依赖另外一个软件。如果一个软件不能正常工作，那么它能够发挥的作用为0。
 
我们现在知道了软件之间的依赖关系：软件i依赖软件Di。现在请你设计出一种方案，安装价值尽量大的软件。一个软件只能被安装一次，如果一个软件没有依赖则Di=0，这时只要这个软件安装了，它就能正常工作。

input

第1行：N,M  （0<=N<=100,0<=M<=500）
      第2行：W1,W2,... Wi,...,Wn （0<=Wi<=M ）
      第3行：V1,V2,Vi,Vn  （0<=Vi<=1000 ）
      第4行：D1,D2,Di,Dn （0<=Di<=N,Di≠i ）

output

一个整数，代表最大价值。

其实能从题意里轻松读出来这是背包问题。
每一个物品向它依赖的物品连边，形成一种树形的结构，每个没有依赖的物品就是根节点。要想要每一个物品，它到它根节点的所有物品全都要取。
但这样就可能不止一棵树了
很容易想到虚拟一个点（如0）来作为所有树的根节点，这样就是一棵树了。再跑一遍树形依赖背包动态规划，就完事儿了
但这样有一个很坑的错误
每种联通的依赖关系，不见得是一棵树
比如1依赖2,2依赖1,没有问题.
所以不能直接虚拟一个点。
先用tarjan缩点，连边，这样才得到了很多的树，虚拟一个根节点，跑一遍树形dp就行了
完整代码：

#include<stdio.h>
#include<cstring>
#include<stack>
using namespace std;
 
stack <int> state;
 
struct edge
{
    int last,u,v;
}ed[100010],ad[100010];
 
int num=0,mum=0,ans=0,cnt=0,n,m,idx=0,INF=1e9;
int head[1010],dfn[1010],low[1010],ins[1010],f[110][510];
int w[110],v[110],pt[110],vis[110],in[510],ww[110],vv[110],hed[10010];
 
void add(int u,int v)
{
    num++;
    ed[num].last=head[u];
    ed[num].v=v;
    ed[num].u=u;
    head[u]=num;
}
 
void ade(int u,int v)
{
    mum++;
    in[v]++;
    ad[mum].v=v;
    ad[mum].last=hed[u];
    hed[u]=mum;
}
 
void tarjan(int u)
{
    dfn[u]=low[u]=++idx;
    vis[u]=ins[u]=1;
    state.push(u);
    for(int i=head[u];i;i=ed[i].last)
    {
        int v=ed[i].v;
        if(!vis[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(ins[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u])
    {
        cnt++;int t=-1;
        while(t!=u)
        {
            t=state.top();
            pt[t]=cnt;
            ww[cnt]+=w[t];
            vv[cnt]+=v[t];
            ins[t]=0;
            state.pop();
        }
    }
}
 
void dfs(int u)
{
    for(int i=hed[u];i;i=ad[i].last)
    {
        int v=ad[i].v;
        dfs(v);
        for(int k=m;k>=0;k--)
            for(int j=k;j>=0;j--)
            f[u][k]=max(f[u][k],f[u][k-j]+f[v][j]);
    }
    for(int j=m;j>=0;j--)
    {
        if(j>=ww[u]) f[u][j]=f[u][j-ww[u]]+vv[u];
        else f[u][j]=0;
    }
}
 
void rebuild()
{
    memset(head,0,sizeof(head));
    for(int i=1;i<=num;i++)
        if(pt[ed[i].u]!=pt[ed[i].v])
        {
            ade(pt[ed[i].u],pt[ed[i].v]);
            in[pt[ed[i].v]]++;
        }
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&w[i]);
    for(int i=1;i<=n;i++)
        scanf("%d",&v[i]);
    for(int i=1;i<=n;i++)
    {
        int u;
        scanf("%d",&u);
        add(u,i);
    }
    for(int i=0;i<=n;i++)
    if(!vis[i]) tarjan(i);
    rebuild();
    int s;
    for(int i=1;i<=cnt;i++)
       if(!in[i]) ade(cnt+1,i);
    dfs(cnt+1);
    printf("%d",f[cnt+1][m]);
    return 0;
}

嗯，就是这样