bzoj2427: [HAOI2010]软件安装

Description

现在我们的手头有N个软件，对于一个软件i，它要占用W_i的磁盘空间，它的价值为V_i。我们希望从中选择一些软件安装到一台磁盘容量为M计算机上，使得这些软件的价值尽可能大（即V_i的和最大）。

但是现在有个问题：软件之间存在依赖关系，即软件i只有在安装了软件j（包括软件j的直接或间接依赖）的情况下才能正确工作（软件i依赖软件j)。幸运的是，一个软件最多依赖另外一个软件。如果一个软件不能正常工作，那么它能够发挥的作用为0。

我们现在知道了软件之间的依赖关系：软件i依赖软件D_i。现在请你设计出一种方案，安装价值尽量大的软件。一个软件只能被安装一次，如果一个软件没有依赖则D_i=0，这时只要这个软件安装了，它就能正常工作。

Input

第1行：N,
M
 （0<=N<=100,
0<=M<=500）
      第2行：W₁,
W₂, ... W_i, ..., W_n （0<=W_i<=M
）
      第3行：V₁,
V₂, ..., V_i, ..., V_n  （0<=Vi<=1000
）
      第4行：D₁,
D₂, ..., D_i, ..., D_n（0<=D_i<=N,
D_i≠i
）

Output

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

Sample Input

3 10
5 5 6
2 3 4
0 1 1

Sample Output

5

HINT

 

Source

Day2

 

题解：

先tarjan缩下点，使其变成一棵树，然后我们就可以进行树上背包了

设f[u][i]表示选到u，用了空间i，得到的最大收益是多少

O（nm²）的转移显然，但其实可以优化到O（nm）

设u的一个儿子是v，则我们可以把f[u]作为初始状态直接付给f[v]，然后就可以减少一个m的转移复杂度

注意把f[u]作为初始状态直接付给f[v]时，f[v]的第二维有下限（就是v及其所有祖先所占的空间和）

code：

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 char ch;
 bool ok;
 void read(int &x){
     ok=;
     for (ch=getchar();!isdigit(ch);ch=getchar()) if (ch=='-') ok=;
     for (x=;isdigit(ch);x=x*+ch-'',ch=getchar());
     if (ok) x=-x;
 }
 const int maxn=;
 const int maxm=;
 const int inf=;
 int n,m,a[maxn],b[maxn],x,ans;
 int f[maxn][maxm],g[maxm];
 int idx,dfn[maxn],low[maxn],stack[maxn],top,cnt,bel[maxn],siz[maxn],val[maxn],deg[maxn];
 bool in[maxn],bo[maxn];
 struct Graph{
     int tot,now[maxn],son[maxn],pre[maxn];
     void put(int a,int b){pre[++tot]=now[a],now[a]=tot,son[tot]=b;}
     void dfs(int u){
         dfn[u]=low[u]=++idx,stack[++top]=u,in[u]=;
         for (int p=now[u],v=son[p];p;p=pre[p],v=son[p])
             if (!dfn[v]) dfs(v),low[u]=min(low[u],low[v]);
             else if (in[v]) low[u]=min(low[u],dfn[v]);
         if (dfn[u]==low[u]){
             int v; ++cnt;
             do{v=stack[top--],bel[v]=cnt,siz[cnt]+=a[v],val[cnt]+=b[v],in[v]=;}while (u!=v);
         }
     }
     /*void dp(int u){
         bo[u]=1;
         memset(f[u],195,sizeof(f[u]));
         f[u][siz[u]]=val[u];
         for (int p=now[u],v=son[p];p;p=pre[p],v=son[p]) if (!bo[v]){
             dp(v);
             memcpy(g,f[u],sizeof(g));
             for (int i=0;i<=m;i++) for (int j=m;j>=i;j--) g[j]=max(g[j],f[v][i]+f[u][j-i]);
             memcpy(f[u],g,sizeof(g));
         }
         f[u][0]=max(f[u][0],0);
     }*/
     /*void dp(int u,int m){
         //cout<<u<<' '<<m<<endl;
         bo[u]=1;
         for (int p=now[u],v=son[p];p;p=pre[p],v=son[p]) if (!bo[v]){
             for (int i=0;i<=m;i++) f[v][i]=f[u][i];
             dp(v,m-siz[v]);
             for (int i=siz[v];i<=m;i++) f[u][i]=max(f[u][i],f[v][i-siz[v]]+val[v]);
         }
     }*/
     void dp(int u,int low){
         bo[u]=;
         for (int p=now[u],v=son[p];p;p=pre[p],v=son[p]) if (!bo[v]){
             for (int i=low;i<=m-siz[v];i++) f[v][i+siz[v]]=f[u][i]+val[v];
             dp(v,low+siz[v]);
             for (int i=low+siz[v];i<=m;i++) f[u][i]=max(f[u][i],f[v][i]);
         }
     }
 }G1,G2;
 int main(){
     read(n),read(m);
     for (int i=;i<=n;i++) read(a[i]);
     for (int i=;i<=n;i++) read(b[i]);
     for (int i=;i<=n;i++) read(x),G1.put(x,i);
     for (int i=;i<=n;i++) if (!dfn[i]) G1.dfs(i);
     for (int u=;u<=n;u++) for (int p=G1.now[u],v=G1.son[p];p;p=G1.pre[p],v=G1.son[p])
         if (bel[u]!=bel[v]) G2.put(bel[u],bel[v]),deg[bel[v]]++;
     for (int u=;u<=n;u++) if (!deg[bel[u]]) G2.put(bel[],bel[u]);
     //G2.dp(bel[0]);
     //G2.dp(bel[0],m);
     G2.dp(bel[],);
     for (int i=;i<=m;i++) ans=max(ans,f[bel[]][i]);
     printf("%d\n",ans);
     return ;
 }