hdu 4044 GeoDefense（DP-树形DP）

GeoDefense

Time Limit: 12000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 686    Accepted Submission(s): 275

Problem Description

Tower defense is a kind of real-time strategy computer games. The goal of tower defense games is to try to stop enemies from reaching your bases by building towers which shoot at them as they pass. 

The choice and positioning of the towers is the essential strategy of the game. Many games, such as Flash Element Tower Defense, feature enemies that run through a "maze", which allows the player to strategically place towers for optimal effectiveness. However, some versions of the genre force the user to create the maze out of their own towers, such as Desktop Tower Defense. Some versions are a hybrid of these two types, with preset paths that can be modified to some extent by tower placement, or towers that can be modified by path placement.

geoDefense is a Thinking Man’s Action Tower Defense. It has become one of "PC World's 10 iPhone Games You CANNOT Live Without". Using exciting vectorized graphics, this highly kinetic game brings a whole new dimension to the defense genre. Devastate creeps with blasters, lasers and missiles and watch their energy debris swirl through the gravity wells of your vortex towers.

There is a geoDefense maze of n points numbered from 1 and connected by passageways. There are at least two dead ends among these n points, and there is always one and only one path between any pair of points. Point 1 is a dead end, and it’s the base of enemies, and all the other dead ends are your bases.

To prevent the enemy reaching your bases, you have to construct towers to attack the enemy. You can build tower on any point and you can only build one tower on one point. A tower can only shot the enemy when it passes the tower. You are given ki choices to build tower on point i, and each choice is given in the format of (price, power) which means that you can build a tower with attack power value equals power in the cost of price. You can also build nothing on a point so it will not cost your money. A tower will reduce the enemy’s HP by its attack power. When the HP is less or equal to zero, the enemy dies immediately. 

The base of enemies will release only one enemy. It moves very fast that you cannot do anything such as building towers while it is running. It runs all the way until it dies or reaches one of your bases. However, you cannot predict the route it will go through. To win the game, you must kill the enemy before it reaches your bases. You have to strategically place towers for optimal effectiveness so that the fortifications are steady enough to protect the bold and powerful enemy with high HP. You are troubling your head on figuring out the highest HP of the enemy you are able to kill on the way certainly. You have money m when the game begins.
Please note that the towers build in the enemy’s base or your bases are all effective and if the enemy is shot to death in your bases, you still win.

 

Input

The input consists of several test cases. The first line is an integer T (1 <= T <= 20), which shows the number of the cases.
For each test case, the first line contains only one integer n (2 <= n <= 1000) meaning the number of points. 
The following n-1 lines describe the passageways. Each line contains two integers u and v, which are the endpoints of a passageway. 
The following line contains only one integer m (1 <= m <= 200) meaning the amount of your money when the game begins. 
Then n lines follow. The ith line describes the construction choices of the ith point. It starts with an integer ki (0 <= ki <= 50) and ki is followed by ki pairs of integers separated by spaces. The jth pair is (pricei,j, poweri,j), 0 <= pricei,j <= 200, 0 <= poweri,j <= 50000. ki being zero means that you can’t build a tower on the ith point. 

 

Output

For each test case, output a line containing the highest HP value of your enemy that you can deal with. It means that if your enemy’s HP is larger than that highest value, you can’t guarantee your victory.

 

Sample Input

  
  

   
   2
2
1 2
30
3 10 20 20 40 30 50
3 10 30 20 40 30 45
4
2 1
3 1
1 4
60
3 10 20 20 40 30 50
3 10 30 20 40 30 45
3 10 30 20 40 30 35
3 10 30 20 40 30 35
  
  

 

Sample Output

  
  

   
   70
80
  
  

 

题意：给一棵树，树根一定是1，敌人在1位置，每个叶子节点是你的基地，每个节点（包括1节点和你的基地）可以建一个防御塔，每个节点有多种防御塔供你选择，告诉你每种防御塔的价钱和防御能力。你现在有m这么多钱，你可以所有节点上建塔，每个节点只能建一个或不建塔。敌人很聪明，它会去摧毁防御最弱的路线（路线上所有点的防御能力之和）的基地。问你防御最弱的路线防御能力的最大值可以是多少？

解题思路：题目给了一棵树，第一反应就是树形DP。

dp[u][i]，表示以u为根的这棵子树，刚好花了i这么多钱，防御最弱路线的最大值是多少。

请看下图，现在，我们假设儿子的结果已经都求出来了，那如何推出父亲节点呢？

首先，假设父亲节点不建防御塔，设tdp[m]表示以f为根的子树，花了刚好m这么多钱，防御最弱路线的最大值，那么：

tdp[m] = min(dp[s1][m1] , dp[s2][m2] , dp[s3][m3] , dp[s4][m4])；

其中m1+m2+m3+m4 = m。这个时候，我们发现，这还得排列组合一下，然后取个最大才对：

tdp[m] = max(  排列组合m1...m4   min(dp[s1][m1] , dp[s2][m2] , dp[s3][m3] , dp[s4][m4])）；

正常我们可以用暴力去枚举m1...m4，然后排列组合一下，但在这里并不合适，会超时。

那么，我们多开一维数组，tdp[n][m]表示前n个儿子用了m这么多钱，防御最弱路线的最大值是多少，初始化为INF。

递推公式为：

若tdp[i][m1+m2] == INF，tdp[i][m1+m2] = min(tdp[i-1][m1] , dp[si][m2]);

否则，tdp[i][m1+m2] = max(tdp[i][m1+m2] , min(tdp[i-1][m1] , dp[si][m2]));

把tdp[n][m]求完之后，我们就知道节点f不建防御塔时，用了m这么多钱，防御最弱路线的最大值。

而每个节点只能建一个防御塔，我们只要枚举一下建哪个防御塔最优就行了，设ta[m]表示用m这么多钱建塔，该塔的防御值。

初始化dp[u][m]为INF，那么：

若dp[u][m1+m2] == INF ，dp[u][m1+m2] = tdp[n][m1]+ta[m2];

否则，dp[u][m1+m2] = max(dp[u][m1+m2] = tdp[n][m1]+ta[m2])；

最后，答案就是max(dp[1][m])。

坑点：一个节点不同防御塔的价格有可能相同。

1 

2 

1 2 

0

2 0 10 0 20 

1 0 10

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

#define INF 1000000000
const int maxn = 1010;
const int maxm = 210;
vector<int> mp[maxn] , power[maxn] , price[maxn];
int dp[maxn][maxm] , tdp[maxn][maxn][maxm];
int n , m;

void initial(){
    for(int i = 0; i < maxn; i++){
        mp[i].clear();
        power[i].clear();
        price[i].clear();
        for(int j = 0; j < maxm; j++) dp[i][j] = INF;
    }
}

void readcase(){
    scanf("%d" , &n);
    int u , v;
    for(int i = 0; i < n-1; i++){
        scanf("%d%d" , &u , &v);
        mp[u].push_back(v);
        mp[v].push_back(u);
    }
    scanf("%d" , &m);
    int k , pri , pow;
    for(int i = 1; i <= n; i++){
        scanf("%d" , &k);
        for(int j = 0; j < k; j++){
            scanf("%d%d" , &pri , &pow);
            if(pri <= m) price[i].push_back(pri) , power[i].push_back(pow);
        }
    }
}

void DP(int u , int f){
    for(int i = 0; i <= mp[u].size()+1; i++){
        for(int j = 0; j <= m; j++) tdp[u][i][j] = INF;
    }
    int sid = 1;
    for(int i = 0; i < mp[u].size(); i++){
        int son = mp[u][i];
        if(son != f){
            DP(son , u);
            for(int k = m; k >= 0; k--){
                if(tdp[u][sid-1][k] == INF && !(sid == 1 && k == 0)) continue;
                for(int j = m-k; j >= 0; j--){
                    if(dp[son][j] == INF) continue;
                    if(tdp[u][sid][j+k] == INF) tdp[u][sid][j+k] = min(tdp[u][sid-1][k] , dp[son][j]);
                    else tdp[u][sid][j+k] = max(tdp[u][sid][j+k] , min(tdp[u][sid-1][k] , dp[son][j]));
                }
            }
            sid++;
        }
    }
    tdp[u][0][0] = 0;
    for(int i = 0; i < price[u].size(); i++){
        if(tdp[u][0][price[u][i]] != INF) tdp[u][0][price[u][i]] = max(tdp[u][0][price[u][i]] , power[u][i]);
        else tdp[u][0][price[u][i]] = power[u][i];
    }
    if(!(mp[u].size() == 1 && mp[u][0] == f)){
        for(int k = m; k >= 0; k--){
            if(tdp[u][0][k] == INF) continue;
            for(int j = m-k; j >= 0; j--){
                if(tdp[u][sid-1][j] == INF) continue;
                if(tdp[u][sid][j+k] == INF) tdp[u][sid][j+k] = tdp[u][0][k]+tdp[u][sid-1][j];
                else tdp[u][sid][j+k] = max(tdp[u][sid][j+k] , tdp[u][0][k]+tdp[u][sid-1][j]);
            }
        }
        sid++;
    }
    for(int i = 0; i <= m; i++){
        if(tdp[u][sid-1][i] == INF) continue;
        dp[u][i] = tdp[u][sid-1][i];
    }
}

void computing(){
    DP(1 , 0);
    int Max =0;
    for(int i = 0; i <= m; i++){
        if(dp[1][i] == INF) continue;
        Max = max(dp[1][i] , Max);
    }
    printf("%d\n" , Max);
}

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        initial();
        readcase();
        computing();
    }
    return 0;
}