HDU 4799 LIKE vs CANDLE 【树形dp】【阅读题】【水题】

LIKE vs CANDLE

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 327680/327680 K (Java/Others)
Total Submission(s): 493    Accepted Submission(s): 152

Problem Description

A microblog caused a war recently - There's the war between LIKE and CANDLE.


As you see, there are N accounts are trying to show their support of LIKE or CANDLE. The way they show the support is forwarding a microblog, which means you choose someone's microblog and repost it with some comment. A valid support microblog is forwarding the original account's microblog or a other valid support microblog. We can assume that all accounts will forward the microblog only once. Also, it is impossible for a microblog forwarding a microblog that posts after it. When the activity ends, someone will use a software to check these accounts and calculate a Power Point for LIKE and CANDLE. Specifically, each account will have a value based on some algorithm (you need not to care). The value will be added to LIKE if the account is voting LIKE, vice versa. So easy, isn't it?
Edward is a programmer and he supports LIKE. He found a bug in the software that used in the activity - He can spend X Power Point of LIKE to flip an account. When an account is flipped, it will be seen as it votes the other side. For example, if Alice votes LIKE and then it is flipped, the software will add the value to CANDLE. Of course, an account can be flipped for several times - If Alice is flipped again, it votes for LIKE again. And if we called the account the flipped account (Notice it's only a concept indicates the account has been flipped and not an attribute of an account), all accounts which forwarding the flipped account's microblog will also be flipped. Soon, Edward found that someone uses this bug before! Some accounts have been flipped already. He can't spend X Power Point to flip them anymore; instead, he need spend Y Power Point to flip an account which has been flipped directly by someone. For the glory of the LIKE, please help Edward to flip accounts so that the Power Point of LIKE can be larger than CANDLE as much as possible.
You can spend Power Point as much as you like, no matter the total Power Point of LIKE is negative or not.

 

Input

The input contains no more than 20 test cases. Notice there's no empty line between each test case.
For each test case, first line has three integers N (1 ≤ N ≤ 50000) - the number of the accounts, X (0 ≤ X ≤ 1000) and Y (0 ≤ Y ≤ 1000) - as the problem description. The account is numbered from 1 to N and 0 represent the original account.
Following N lines, the i^th line means the i^th account. Each line has four integers: V (0 ≤ V ≤ 1000) - the value of the i^th account, F (0 ≤ F ≤ N) - which account did the i^th account's forwarding account come from (0^th microblog is original account's microblog), S (0 ≤ S ≤ 1) - the status of flipped (0 means no changed, 1 means changed) and P (0 ≤ P ≤ 1) - the side the account supports without flipped (0 means LIKE, 1 means CANDLE).
The original microblog's account can't be flipped, and it hasn't the value and the support side.

 

Output

For each test case print an integer, represents the maximum result of the value of LIKE minus the value of CANDLE. If the value of CANDLE is larger than the LIKE, then just output "HAHAHAOMG" (without quote).

 

Sample Input

4 3 2
5 0 0 0
3 1 0 1
4 2 1 0
1 2 0 0

 

Sample Output

8

 

Source

2013 Asia Changsha Regional Contest

题意：
若干微博账户形成了一个转发树（即一个有根树）。每个账户有自己的价值，每个账户也有自己的态度（赞或蜡烛）。如果一个账户的态度是“赞”，它的价值就会被加到“赞”的一边，反之亦然。Edward可以从“赞”的一边拿出X 的价值去翻转一个账户，即把它的态度换到相反的一边。但是Edward 发现，有的账户已经被别人翻转过了，对于这些账户，Edward就要花费Y的价值去翻转它们。一旦一个账户被翻转了一次，它的所有子账户也会被翻转一次。求“赞”的一边的价值总数与“蜡烛”一边的价值总数的最大差值。若最大差值为负数则输出“HAHAHAOMG”。

思路：

dp[i][0]表示第i个节点不翻转的最优解，dp[i][1]表示翻转的最优解，每个位置翻转的代价到其父亲节点的位置再计算。

#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>
#include<iomanip>
#define INF 0x3f3f3f3f
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;

const int maxn = 50005;

int N, X[2], W[maxn], F[maxn], V[maxn];
vector<int> G[maxn];
int dp[maxn][2];

void init() {
	int u;
	for (int i = 0; i <= N; i++) G[i].clear();

	for (int i = 1; i <= N; i++) {
		scanf("%d%d%d%d", &W[i], &u, &F[i], &V[i]);
		if (V[i]) W[i] *= -1;
		G[u].push_back(i);
	}
}

int dfs(int u, int d) {

	d ^= F[u];
	if (d) W[u] = -W[u];
	dp[u][0] = W[u];
	dp[u][1] = -W[u];

	for (int i = 0; i < G[u].size(); i++) {
		int v = G[u][i];
		dfs(v, d);
		dp[u][0] += max(dp[v][0], dp[v][1] - X[F[v]]);
		dp[u][1] += max(dp[v][0] - X[F[v]], dp[v][1]);
	}

	return dp[u][0];
}

int main() {
	while (~scanf("%d%d%d", &N, &X[0], &X[1]))
	{
		init();
		int ans = dfs(0, 0);
		if (ans < 0) printf("HAHAHAOMG\n");
		else printf("%d\n", ans);
	}
	return 0;
}