树形dp mark

A - Anniversary party HDU - 1520 

题意是 有一个树 每个点都有一个价值，选了父亲节点就不能选子节点 选了子节点就不能选父亲节点 

问最后能得到的最大价值是多少

树形dp入门  定义状态 dp[i][1]表示选中此节点 dp[i][0]表示未选中此节点

那么 dp[i][1]=sigma(dp[j][0])+a[i]; //j为i的儿子节点

dp[i][0]=sigma(max(dp[j][1],dp[j][0]))+a[i];

另外无论如何都要吐槽一下这题的输入格式！！！！

 

#include<bits/stdc++.h>
using namespace std;
int n;
const int maxn=6060;

vector<int>G[maxn];
int v[6060];
int dp[maxn][2];
int pre[maxn];

int dfs(int x)
{
    dp[x][1]=v[x];
    for(int i=0;i<G[x].size();i++)
        dfs(G[x][i]);
    for(int i=0;i<G[x].size();i++)
    {
        dp[x][1]+=dp[G[x][i]][0];
        dp[x][0]+=max(dp[G[x][i]][1],dp[G[x][i]][0]);
    }
}

int main()
{
    int x,y;
    while(~scanf("%d",&n)){
    for(int i=0;i<=n;i++) G[i].clear();
    for(int i=1;i<=n;i++) scanf("%d",&v[i]);
    memset(pre,-1,sizeof(pre));
    while(~scanf("%d%d",&x,&y))
    {
        if(x==0||y==0) break;
        G[y].push_back(x);
        pre[x]=y;
    }

    memset(dp,0,sizeof(dp));

    int root=1;
    while(pre[root]!=-1) root=pre[root];
    dfs(root);
    printf("%d\n",max(dp[root][0],dp[root][1]));
}
}

 

B - Computer

 HDU - 2196 

给一个树 求每个节点能够到达的最远距离是多少？

定义dp[i][0]为i节点向下走的最远距离,自下而上

dp[i][1]为i节点向下走的次远距离，自下而上

dp[i][2]为i节点向上走的最远距离，自上而下

那么每一个节点能够到达的最远距离与 儿子节点到达的距离有关 与父亲节点到达的距离有关

那么就需要两次dfs , 第一次自下而上 维护一个 dp[i][0],dp[i][1],

第二次dfs 自上而下 维护一下 dp[i][2];

 

#include<bits/stdc++.h>
using namespace std;

typedef pair<int,int> pii;

const int maxn=1e4+5;

int n;
vector<pii >G[maxn];

int dp[maxn][3];

int dfs1(int u)
{
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i].first;
        int w=G[u][i].second;
        dfs1(v);
        if(dp[u][0]<=dp[v][0]+w)
        {
            dp[u][1]=dp[u][0];
            dp[u][0]=dp[v][0]+w;
        }
        else if(dp[v][0]+w>dp[u][1])
            dp[u][1]=dp[v][0]+w;
    }
}

int dfs2(int u)
{
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i].first;
        int w=G[u][i].second;
        if(dp[u][0]!=dp[v][0]+w)
        {
            dp[v][2]=max(dp[u][0]+w,dp[u][2]+w);
        }
        else{
            dp[v][2]=max(dp[u][1]+w,dp[u][2]+w);
        }
        dfs2(v);
    }
}

int main()
{
    int x,y;
    while(~scanf("%d",&n))
    {
        for(int i=0;i<=n;i++) G[i].clear();
        for(int i=2;i<n+1;i++)
        {
            scanf("%d%d",&x,&y);
            G[x].push_back({i,y});
        }

        memset(dp,0,sizeof(dp));

        dfs1(1);
        dfs2(1);

        for(int i=1;i<=n;i++)
            printf("%d\n",max(dp[i][0],dp[i][2]));
    }
}