HDU 4276 - The Ghost Blows Light

The Ghost Blows Light

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3345    Accepted Submission(s): 1040

Problem Description

　　My name is Hu Bayi, robing an ancient tomb in Tibet. The tomb consists of N rooms (numbered from 1 to N) which are connected by some roads (pass each road should cost some time). There is exactly one route between any two rooms, and each room contains some treasures. Now I am located at the 1st room and the exit is located at the Nth room.
Suddenly, alert occurred! The tomb will topple down in T minutes, and I should reach exit room in T minutes. Human beings die in pursuit of wealth, and birds die in pursuit of food! Although it is life-threatening time, I also want to get treasure out as much as possible. Now I wonder the maximum number of treasures I can take out in T minutes.

 

Input

 

　　There are multiple test cases.
The first line contains two integer N and T. (1 <= n <= 100, 0 <= T <= 500)
Each of the next N - 1 lines contains three integers a, b, and t indicating there is a road between a and b which costs t minutes. (1<=a<=n, 1<=b<=n, a!=b, 0 <= t <= 100)
The last line contains N integers, which Ai indicating the number of treasure in the ith room. (0 <= Ai <= 100)

 

Output

 

　　For each test case, output an integer indicating the maximum number of treasures I can take out in T minutes; if I cannot get out of the tomb, please output "Human beings die in pursuit of wealth, and birds die in pursuit of food!".

 

Sample Input

 

5 10

1 2 2

2 3 2

2 5 3

3 4 3

1 2 3 4 5

 

Sample Output

 

11

 

题意：

　　有一棵树，有n个节点，每个节点有一个权值，每一条边有一个时间，在经过的时间不超过给定时间m的情况下，求从1点到n点的路径的最大权值

思路：

　　对于一棵树只有一条 从根节点到某节点的最短路，所以先判断这条最短路是不是符合条件，符合的话，把这条路上的点记为0，然后就是树形DP求解，

因为要走其他点，必须再回来，所以回来时要乘以二所经过的路径

这是个背包问题：

状态转移方程为，dp[i][j]=max(dp[i][j],dp[i][k]+dp[i][j-2*val-k])

AC代码：

# include <bits/stdc++.h>
using namespace std;

const int MAX = 120;
struct node
{
    int to;
    int next;
    int t;
}tree[MAX];
int head[MAX];
int tol = 0;
int w[MAX];
int n, t;
int Mint;
int dp[MAX][600];

void add(int a, int b, int val)
{
    tree[tol].to = b;
    tree[tol].next = head[a];
    tree[tol].t = val;
    head[a] = tol++;
}

bool dfs1(int root, int f)
{
    if(root == n)
        return true;//找到了
    for(int i = head[root]; i != -1; i = tree[i].next)
    {
        int son = tree[i].to;
        if(son == f)
            continue;
        if(dfs1(son, root))
        {
            Mint += tree[i].t;
            tree[i].t = 0;
            return true;
        }
    }
    return false;
}

void dfs2(int root, int f)
{
    for(int i = 0; i <= t; i++)
        dp[root][i] = w[root];
    for(int i = head[root]; i != -1; i = tree[i].next)
    {
        int son = tree[i].to;
        if(son == f)
            continue;
        dfs2(son, root);
        int cost = tree[i].t * 2;
        for(int j = t; j >= cost; j--)
        {
            for(int k = 0; k <= j - cost; k++)
                dp[root][j] = max(dp[root][j], dp[root][j - k - cost] + dp[son][k]);
        }
    }
}
int main()
{
    while(scanf("%d%d", &n, &t) != EOF)
    {
        memset(head, -1, sizeof(head));
        memset(dp, 0, sizeof(dp));
        tol = 0;
        Mint = 0;
        int a, b, val;
        for(int i = 1; i < n; i++)
        {
            scanf("%d%d%d", &a, &b, &val);
            add(a, b, val);
            add(b, a, val);
        }
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &w[i]);
        }
        dfs1(1, -1);// 看看直接走去的最短时间是多少，
        if(Mint > t)
        {
            printf("Human beings die in pursuit of wealth, and birds die in pursuit of food!\n");
            continue;
        }
        t -= Mint;
        dfs2(1, -1);
        printf("%d\n", dp[1][t]);
    }
    return 0;
}