POJ 2342 Anniversary party 入门树dp

类似: POJ 1463 Strategic game

题意: 给出一颗树, 每个节点有价值, 现从中取出若干个点, 但是相邻的点不能都取, 求最大的总价值.

思路:

树dp

①dp[0][x]代表x这个点不取时, 以x为根节点的子树能获得的总价值.

②dp[1][x]代表x这个点取时, 以x为根节点的子树能获得的总价值.

①: 此时, x的儿子节点可以取, 也可以不取(当然是选择大的那个啦)     dp[0][x]=Σmax(dp[0][soni],dp[1][soni])

②: 此时, x的儿子节点都不能取     dp[1][x]=Σdp[0][soni] + v[x]

代码:

//#include<bits/stdc++.h>
#include <queue>
#include <stack>
#include <cstring>
#include <iostream>
#include <cstdio>

using namespace std;

void debug_out() {
    cerr << '\n';
}

template<typename T, typename ...R>
void debug_out(const T &f, const R &...r) {
    cerr << f << " ";
    debug_out(r...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__);

typedef long long ll;

const int M = 6005;
const int inf = 1e9 + 5;
const int mod = 1e9 + 7;

int v[M];
int head[M];
int ei;
struct node {
    int v, nxt;
} edge[M];
int n;

void addEdge(int x, int y) {
    edge[ei].v = y;
    edge[ei].nxt = head[x];
    head[x] = ei++;
}

int fa[M];
int List[M];//拓扑排序(从叶到根)后的数组
int li;
int s = 0;//root
int dp[2][M];


void bfs() {//拓扑排序
    li = 0;
    int x = s;
    stack<int> stack1;
    queue<int> q;
    q.push(x);
    while (!q.empty()) {
        x = q.front();
        q.pop();
        stack1.push(x);
        for (int i = head[x]; i != -1; i = edge[i].nxt) {
            int v = edge[i].v;
            q.push(v);
        }
    }
    while (!stack1.empty()) {
        List[li++] = stack1.top();
        stack1.pop();
    }
}


void init() {
    memset(fa, 0, sizeof(fa));
    memset(head, -1, sizeof(head));
    ei = 0;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &v[i]);
    }
    for (int i = 0; i < (n - 1); i++) {
        int SON, FATHER;
        scanf("%d%d", &SON, &FATHER);
        addEdge(FATHER, SON);
        fa[SON] = FATHER;
    }
    for (int i = 1; i <= n; i++) {
        if (fa[i] == 0) {
            s = i;
            break;
        }
    }
    bfs();
}

void solve() {
    memset(dp, 0, sizeof(dp));
    for (int i = 0; i < n; i++) {
        int u = List[i];
        int sum0 = 0, sum1 = 0;
        for (int j = head[u]; j != -1; j = edge[j].nxt) {
            int v = edge[j].v;
            sum0 += max(dp[1][v], dp[0][v]);
            sum1 += dp[0][v];
        }
        dp[0][u] = sum0;
        dp[1][u] = sum1 + v[u];
    }
    printf("%d\n", max(dp[0][s], dp[1][s]));
}

int main() {
    while (scanf("%d", &n) && n) {
        init();
        solve();
    }
    return 0;
}

看到网上都是记搜dfs写的...我写的是bfs找拓扑序+dp写的...嘤嘤嘤