HLG1475国王的宴会【树形DP】

大意：

你知道国王喜欢热闹，所以你希望能邀请尽量多的人，但是做为直接上下级关系的两个人直接出现在宴会上的时候会显得很尴尬，所以不能同时请有上下级关系的两个人。

国王是宴会的主办方，也是这个王国的最高领袖，所以必须到场。

为了能为宴会准备的更好，你需要知道整个宴会最多可以邀请多少宾客。

分析 ：

树形DP

dp[x][0]代表x及其子树在不选x的情况下的最优解

dp[x][1]代表x及其子树在选x的情况下的最优解

那么  dp[x][0] = sum(max(dp[y][0], dp[y][1]))

　　　dp[x][1] = sum(dp[y][0]) + 1

由于boss一定在场 所以最终结果保留在 dp[boss][1]之中

 

代码:

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

const int maxn = 1005;
int n, m;

struct Node {
    int to, next;
}e[maxn * maxn];
int head[maxn];
int tot;
void add(int u, int v) {
    e[tot].to = v;
    e[tot].next = head[u];
    head[u] = tot++;
}
int H[maxn], T[maxn];
int boss;

int dp[maxn][2];

void dfs(int u) {
    if(H[u] == 0) {
        dp[u][0] = 0;
        dp[u][1] = 1;
        return ;
    } 
    int sum1 = 0; int sum2 = 0;
    for(int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        dfs(v);
        sum1 += dp[v][0];
        sum2 += max(dp[v][0], dp[v][1]);
    }
    dp[u][1] = sum1 + 1;
    dp[u][0] = sum2;
}

int DP() {
    memset(dp, 0, sizeof(dp));
    dfs(boss);
    return dp[boss][1];
}

int main() {
    int u, v;
    while(EOF != scanf("%d %d",&n, &m) ) {
        tot = 1;
        memset(head, 0, sizeof(head));
        memset(H, 0, sizeof(H));
        memset(T, 0, sizeof(T));
        for(int i = 1; i <= m; i++) {
            scanf("%d %d",&u, &v);
            add(u, v);
            H[u]++; T[v]++;
        }
        for(int i = 1; i <= n; i++) {
            if(T[i] == 0) {
                boss = i;
                break;
            }
        }
        printf("%d\n", DP());
    }
    return 0;
}