树形背包 POJ1155TELE

题目描述

某收费有线电视网计划转播一场重要的足球比赛。他们的转播网和用户终端构成一棵树状结构，这棵树的根结点位于足球比赛的现场，树叶为各个用户终端，其他中转站为该树的内部节点。

从转播站到转播站以及从转播站到所有用户终端的信号传输费用都是已知的，一场转播的总费用等于传输信号的费用总和。

现在每个用户都准备了一笔费用想观看这场精彩的足球比赛，有线电视网有权决定给哪些用户提供信号而不给哪些用户提供信号。

写一个程序找出一个方案使得有线电视网在不亏本的情况下使观看转播的用户尽可能多。

输入输出格式

输入格式：

输入文件的第一行包含两个用空格隔开的整数N和M，其中2≤N≤3000，1≤M≤N-1，N为整个有线电视网的结点总数，M为用户终端的数量。

第一个转播站即树的根结点编号为1，其他的转播站编号为2到N-M，用户终端编号为N-M+1到N。

接下来的N-M行每行表示—个转播站的数据，第i+1行表示第i个转播站的数据，其格式如下：

K A1 C1 A2 C2 … Ak Ck

K表示该转播站下接K个结点(转播站或用户)，每个结点对应一对整数A与C，A表示结点编号，C表示从当前转播站传输信号到结点A的费用。最后一行依次表示所有用户为观看比赛而准备支付的钱数。

输出格式：

输出文件仅一行，包含一个整数，表示上述问题所要求的最大用户数。

输入输出样例

输入样例#1： 复制

5 3
2 2 2 5 3
2 3 2 4 3
3 4 2

输出样例#1： 复制

2

说明

样例解释

如图所示，共有五个结点。结点①为根结点，即现场直播站，②为一个中转站，③④⑤为用户端，共M个，编号从N-M+1到N，他们为观看比赛分别准备的钱数为3、4、2，从结点①可以传送信号到结点②，费用为2，也可以传送信号到结点⑤，费用为3（第二行数据所示），从结点②可以传输信号到结点③，费用为2。也可传输信号到结点④，费用为3（第三行数据所示），如果要让所有用户（③④⑤）都能看上比赛，则信号传输的总费用为：

2+3+2+3=10，大于用户愿意支付的总费用3+4+2=9，有线电视网就亏本了，而只让③④两个用户看比赛就不亏本了。

算法分析：

树形背包DP的典型例题

明确dp[i][j]含义，表示i节点，选j个用户，能得到的钱的最大值，然后对每个节点做分组背包。

首先，背包的总容量相当于该点为根节点的子树中所有的用户数量（dp[i][j]的 j 不可能超过它连接的所有用户数）。然后，把该节点的每个儿子看成一组，每组中的元素为选一个，选两个...选n个用户。

转移方程 dp[i][j]=max(dp[i][j],dp[i][j-k]+dp[v][k]-这条边的花费) i,j不解释了，v表示枚举到这一组（即i的儿子），k表示枚举到这组中的元素：选k个用户。

最后输出dp[1][i]>=0的i的最大值，所以反向枚举。

简单来说就是把每个节点看成一个背包啦，它的容量就是以这个节点为根的子树大小，组数就是连接的儿子个数。

每组都有很多选择，选一个，两个，三个用户，把这些选择当做组中的元素就好了，容易看出每组中只能选一个元素，比如你选择了选一个用户，就不可能同时选择选两个用户。

代码实现：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int N=3010;
struct node
{
    int v;///终端点
    int next;///下一条同样起点的边号
    int w;///权值
}edge[N*2];///无向边，2倍
int head[N];///head[u]=i表示以u为起点的所有边中的第一条边是 i号边
int tot;  ///总边数
int minn;
int v[N],num[N];
void add(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
int n,m;
int dp[N][N];
void dfs(int u,int fa) 
{
    
    //int num=0;     ///记录u的节点数，背包容量
    dp[u][0]=0;
    if(u>n-m)
    {
        dp[u][1]=v[u];
        num[u]=1;
        return ;
    }      
    for(int i=head[u];i!=-1;i=edge[i].next)
     {
        int v= edge[i].v;
        if(fa==v) continue;   ///如果下一个相邻节点就是父节点，则证明到底层了，开始递归父节点的兄弟节点
        
        dfs(v,u);
        num[u]+=num[v];
        for(int j=num[u];j>0;j--)    ///背包容量
            for(int k=1;k<=num[v];k++)   ///选择用户
        {
            dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]-edge[i].w);
        }
     }

}
int main()
{
    scanf("%d%d",&n,&m) ;
    memset(head,-1,sizeof(head));
    memset(num,0,sizeof(num));
    memset(dp,~0x3f,sizeof(dp)); 
    tot=0;
    
    for(int i=1;i<=n-m;i++)
    {
        
        int w,v,num;
        scanf("%d",&num);
        for(int j=1;j<=num;j++)
        {
        scanf("%d%d",&v,&w);
        add(i,v,w); 
        add(v,i,w); 
        }   
    }
    for(int i=n-m+1;i<=n;i++)
        scanf("%d",&v[i]);
    dfs(1,-1);  
    for (int i=n;i>=1;i--)
        if (dp[1][i]>=0)
        {
            printf("%d",i);
            break;
        } 
    
    return 0;
}