VK Cup 2015 - Round 2 (unofficial online mirror, Div. 1 only) B. Work Group 树形dp

题目链接：

http://codeforces.com/problemset/problem/533/B

B. Work Group

time limit per test2 seconds
memory limit per test256 megabytes

问题描述

One Big Software Company has n employees numbered from 1 to n. The director is assigned number 1. Every employee of the company except the director has exactly one immediate superior. The director, of course, doesn't have a superior.

We will call person a a subordinates of another person b, if either b is an immediate supervisor of a, or the immediate supervisor of a is a subordinate to person b. In particular, subordinates of the head are all other employees of the company.

To solve achieve an Important Goal we need to form a workgroup. Every person has some efficiency, expressed by a positive integer ai, where i is the person's number. The efficiency of the workgroup is defined as the total efficiency of all the people included in it.

The employees of the big software company are obsessed with modern ways of work process organization. Today pair programming is at the peak of popularity, so the workgroup should be formed with the following condition. Each person entering the workgroup should be able to sort all of his subordinates who are also in the workgroup into pairs. In other words, for each of the members of the workgroup the number of his subordinates within the workgroup should be even.

Your task is to determine the maximum possible efficiency of the workgroup formed at observing the given condition. Any person including the director of company can enter the workgroup.

输入

The first line contains integer n (1 ≤ n ≤ 2·105) — the number of workers of the Big Software Company.

Then n lines follow, describing the company employees. The i-th line contains two integers pi, ai (1 ≤ ai ≤ 105) — the number of the person who is the i-th employee's immediate superior and i-th employee's efficiency. For the director p1 =  - 1, for all other people the condition 1 ≤ pi < i is fulfilled.

输出

Print a single integer — the maximum possible efficiency of the workgroup.

样例输入

7

-1 3

1 2

1 1

1 4

4 5

4 3

5 2

样例输出

17

Note

In the sample test the most effective way is to make a workgroup from employees number 1, 2, 4, 5, 6.

题意

给你一颗树和点权，问你找出满足当x在集合里面时，它的后代的个数恰好为偶数个的内权值和最大的集合。

题解

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<stack>
#include<ctime>
#include<vector>
#include<cstdio>
#include<string>
#include<bitset>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
#define X first
#define Y second
#define mkp make_pair
#define lson (o<<1)
#define rson ((o<<1)|1)
#define mid (l+(r-l)/2)
#define sz() size()
#define pb(v) push_back(v)
#define all(o) (o).begin(),(o).end()
#define clr(a,v) memset(a,v,sizeof(a))
#define bug(a) cout<<#a<<" = "<<a<<endl
#define rep(i,a,b) for(int i=a;i<(b);i++)
#define scf scanf
#define prf printf

typedef __int64 LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
typedef vector<pair<int,int> > VPII;

const int INF=0x3f3f3f3f;
const LL INFL=0x3f3f3f3f3f3f3f3fLL;
const double eps=1e-8;
const double PI = acos(-1.0);

//start----------------------------------------------------------------------

const int maxn=2e5+10;

/// dp[u][0]表示以u为根的子树节点数为偶数的合法最大值，
///同理dp[u][1]表示节点数为奇数的情况。
LL dp[maxn][2];
int n;
int arr[maxn];

VI G[maxn];

void dfs(int u){
    if(G[u].sz()==0){
        dp[u][0]=0;
        dp[u][1]=arr[u];
        return;
    }
    dp[u][0]=0;
    ///这个初始化不要写错！！！！！！
    dp[u][1]=-INF;
    rep(i,0,G[u].sz()){
        int v=G[u][i];
        dfs(v);
        LL t0,t1;
        t0=max(dp[u][0]+dp[v][0],dp[u][1]+dp[v][1]);
        t1=max(dp[u][0]+dp[v][1],dp[u][1]+dp[v][0]);
        dp[u][0]=t0;
        dp[u][1]=t1;
    }
    dp[u][1]=max(dp[u][1],dp[u][0]+arr[u]);
}

int main() {
    scf("%d",&n);
    int rt;
    for(int i=1;i<=n;i++){
        int p;
        scf("%d%d",&p,&arr[i]);
        if(p==-1) rt=i;
        else G[p].pb(i);
    }

    dfs(rt);

    prf("%I64d\n",max(dp[rt][0],dp[rt][1]));

    return 0;
}

//end-----------------------------------------------------------------------

Notes

这题一开始就想到考虑每个点在和不在的情况，结果发现好难转移。。

其实这题有个特点就是状态之和子孙个数有关，而且只考虑奇偶性，所以应该要往这方面想的！。。

以后觉得状态很难转的时候可以考虑下问题的性质，对照自己的状态是否合适，是否有其他更好的状态表示。