树形动规_(二叉苹果树)

二叉苹果树(Ural)
apple.pas/c/cpp
【问题描述】
有一棵苹果树，如果树枝有分叉，一定是分 2叉（就是说没有只有 1个儿子的结点）。这棵树共有 N 个结点
（叶子点或者树枝分叉点），编号为1-N,树根编号一定是 1。我们用一根树枝两端连接的结点的编号来描述一根
树枝的位置。下面是一颗有 4 个树枝的树。
   2   5
    \ / 
     3   4
      \ /
       1
现在这颗树枝条太多了，需要剪枝。但是一些树枝上长有苹果。给定需要保留的树枝数量，求出最多能留住
多少苹果。
【输入格式】
第 1 行 2 个数，N 和 Q(1<=Q<= N,1N 表示树的结点数，Q 表示要保留的树枝数量。接下来 N-1 行描述树枝的信息。
每行 3 个整数，前两个是它连接的结点的编号。第 3 个数是这根树枝上苹果的数量。
每根树枝上的苹果不超过 30000 个。
【输出格式】
一个数，最多能留住的苹果的数量。
【输入样例】
5 2
1 3 1
1 4 10
2 3 20
3 5 20
【输出样例】
21
【时间限制】
1s
【空间限制】
64M

//----------------------------------------------------------------------------------------

分析:稍微转化一下,和选课没区别,用树形依赖背包解决.

f[i,j]表示以i为根的子树保留j个树枝所能留住的最多的苹果数.

code:

type  edge=record
      v,w,n:longint;
end;
const maxn=101;
var   e:array[0..maxn*2] of edge;
      t:array[0..maxn,0..1] of longint;
      f:array[0..maxn,0..maxn] of longint;
      vis:array[0..maxn] of boolean;
      s,h:array[0..maxn] of longint;
      n,q,i,u,v,w,cnt:longint;

      procedure buildtree(u:longint);
      var   v,p,x:longint;
      begin
            vis[u]:=true;
            p:=h[u];
            x:=0;
            while p<>0 do
            begin
                  v:=e[p].v;
                  if not vis[v] then
                  begin
                        t[u,x]:=v;
                        s[v]:=e[p].w;
                        inc(x);
                        buildtree(v);
                  end;
                  p:=e[p].n;
            end;
      end;

      procedure add(u,v,w:longint);
      begin
            inc(cnt);
            e[cnt].v:=v;
            e[cnt].w:=w;
            e[cnt].n:=h[u];
            h[u]:=cnt;
      end;

      function max(a,b:longint):longint;
      begin
            if a>b then exit(a); exit(b);
      end;

      procedure dfs(u,c:longint);
      var   v,o,j:longint;
      begin
            if c=0 then exit;
            for o:=0 to 1 do
            begin
                  v:=t[u,o];
                  if v=0 then continue;
                  for j:=0 to c do f[v,j]:=f[u,j];
                  dfs(v,c-1);
                  for j:=1 to c do
                     f[u,j]:=max(f[u,j],f[v,j-1]+s[v]);
            end;
      end;

begin
      assign(input,'apple.in'); reset(input);
      assign(output,'apple.out'); rewrite(output);

      readln(n,q);
      for i:=1 to n-1 do
      begin
            readln(u,v,w);
            add(u,v,w);
            add(v,u,w);
      end;

      buildtree(1);

      dfs(1,q);
      writeln(f[1,q]);

      close(input);
      close(output);
end.

转载于:https://www.cnblogs.com/exponent/archive/2011/08/06/2129511.html