【HAOI2010】【强连通分量】【树形动态规划】软件安装

这道题是一道水题。。。

由于软件的依赖关系可能是一个环，所以先将原图缩点。

将缩点后的树转化为二叉树后f[i][j]表示以i为跟的子树分配j的空间得到的最大价值，l[i],r[i]表示i的左儿子和右儿子

则f[i][j] = max(f[r[i]][j],f[l[i]][k] + f[r[i]][j - k - w[i]] + v[i])

使用记忆化实现。

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100 + 10;
const int maxm = 500 + 10;
struct tree
{
int l,r;
tree(){l = r = -1;}
}Tree[maxn];
struct pnode
{
int pos;
pnode *next;
pnode(){}
pnode(int pos,pnode *next):pos(pos),next(next){}
}*first[maxn],__[maxn],*tot = __;
int w[maxn],v[maxn],nw[maxn],nv[maxn];
int dfn[maxn],low[maxn],stack[maxn];
int belong[maxn],dig[maxn];
int f[maxn][maxm];
bool instack[maxn],map[maxn][maxn];
int step = 0,stop = 0,cnt = 0;
int n,m;

void init()
{
freopen("bzoj2427.in","r",stdin);
freopen("bzoj2427.out","w",stdout);
}

void readdata()
{
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 tmp;
scanf("%d",&tmp);
first[tmp] = new(tot++)pnode(i,first[tmp]);
}
}

void tarjan(int u)
{
dfn[u] = low[u] = ++step;
stack[stop++] = u;
instack[u] = true;
for(pnode *p = first[u];p != NULL;p = p -> next)
{
int v = p -> pos;
if(!dfn[v])
{
tarjan(v);
if(low[v] < low[u])low[u] = low[v];
}
else if(instack[v] && dfn[v] < low[u])low[u] = dfn[v];
}
if(dfn[u] == low[u])
{
cnt++;
int tmp;
do
{
tmp = stack[--stop];
instack[tmp] = false;
belong[tmp] = cnt;
nw[cnt] += w[tmp];
nv[cnt] += v[tmp];
}while(tmp != u);
}
}

void build_map()
{
for(int u = 1;u <= n;u++)
{
for(pnode *p = first[u];p != NULL;p = p -> next)
{
int v = p -> pos;
if(belong[u] != belong[v])
{
++dig[belong[v]];
map[belong[u]][belong[v]] = true;
}
}
}
}

void build_tree(int k)
{
for(int i = 1;i <= cnt;i++)
{
if(map[k][i])
{
if(Tree[k].l == -1)Tree[k].l = i;
else
{
int t = Tree[k].l;
while(Tree[t].r != -1)t = Tree[t].r;
Tree[t].r = i;
}
}
}
if(Tree[k].l != -1)build_tree(Tree[k].l);
if(Tree[k].r != -1)build_tree(Tree[k].r);
}

int dfs(int d,int k)
{
if(d == -1)return 0;
if(f[d][k] != -1)return f[d][k];
f[d][k] = dfs(Tree[d].r,k);
for(int i = 0;i <= k - nw[d];i++)
{
f[d][k] = max(f[d][k],dfs(Tree[d].l,i) + dfs(Tree[d].r,k - i - nw[d]) + nv[d]);
}
return f[d][k];
}

void solve()
{
memset(f,-1,sizeof(f));
step = stop = 0;
for(int i = 1;i <= n;i++)
{
if(!dfn[i])tarjan(i);
}
build_map();
for(int i = 1;i <= cnt;i++)
{
if(!dig[i])map[0][i] = true;
}
build_tree(0);
printf("%d\n",dfs(0,m));
}

int main()
{
init();
readdata();
solve();
return 0;
}