POJ 2342 Anniversary party 入门树dp

题意: 除了一个人之外, 每个人都有价值, 每个人都有直接上级, 现在要开一个party, 取了一个人就不能取他的直接上级, 问最多能取到多少价值.

思路:

直接树dp. 之前写的代码是记搜, 我发现可以先拓扑排序再dp...

记搜:

 

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

int n;
int dp[6005][2];
int father[6005]= {0};
int book[6005]= {0};
int l,k;
int bigboss=0;
int vis[6005]={0};

void dfs(int x)
{
    vis[x]=1;
    for(int i=1;i<=n;i++)
    {
        if(father[i]==x&&vis[i]==0)
        {
            dfs(i);
            dp[x][0]+=max(dp[i][0],dp[i][1]);
            dp[x][1]+=dp[i][0];
        }
    }
}

int main()
{
    cin>>n;
    for(int i=1; i<=n; i++)
        cin>>dp[i][1];
    while(scanf("%d%d",&l,&k))
    {
        if(l==0&&k==0)
            break;
        father[l]=k;
        book[l]++;
    }
    for(int i=1; i<=n; i++)
    {
        if(book[i]==0)
            bigboss=i;
    }
    dfs(bigboss);
    cout<<max(dp[bigboss][0],dp[bigboss][1]);
}

topsort+dp

#include<bits/stdc++.h>
using namespace std;
const int M = 6005;

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;

void bfs(int x) {
    li = 0;
    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();
    }
}

int s = 0;

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 x, y;
        scanf("%d%d", &x, &y);
        addEdge(y, x);
        fa[x] = y;
    }
    for (int i = 1; i <= n; i++) {
        if (fa[i] == 0) {
            s = i;
            break;
        }
    }
    bfs(s);
}

int dp[2][M];


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[0][x]代表不取这个人, 他的儿子是可以取可以不取的
        dp[1][u] = sum1 + v[u];//dp[1][x]代表取这个人, 那么它的儿子就不能取.
    }
    printf("%d\n", max(dp[0][s], dp[1][s]));
}

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

    return 0;
}