hdu--1520--树形dp<写起来就是深搜啊>-<滚动数组优化>

我肯定还没怎么理解树形dp啊...为什么写下去 就感觉是多了个状态转移方程的深搜呢？或者因为树形dp是依托在树这个数据结构上所进行的 所以是这样的？

这题 被很多人 当做树形dp的入门题 的确....

如果 u 是 v 的前驱即父母 那么

dp[u][0] += max( dp[v][1] , dp[v][0] ) 0表示u不包括在内 1在内

dp[u[[1] += dp[v][0]

不太难写 还好这个

主要是 每个树形dp都要找出根结点

因为数据很宽松 我直接用了vector来写

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int size = 6010;
vector<int>ve[size];
int val[size];
int dp[size][2];
int in[size];

void dfs( int u )
{
    int Size , v;
    Size = ve[u].size();
    dp[u][1] = val[u];
    for( int i = 0 ; i<Size ; i++ )
    {
        v = ve[u][i];
        dfs(v);
        dp[u][0] += max( dp[v][0] , dp[v][1] );
        dp[u][1] += dp[v][0];
    }
}

int main()
{
    cin.sync_with_stdio(false);
    int n , x , y , z;
    while( cin >> n )
    {
        memset( dp , 0 , sizeof(dp) );
        memset( in , 0 , sizeof(in) );
        for( int i = 1 ; i<=n ; i++ )
        {
            cin >> val[i];
            ve[i].clear();
        }
        while(1)
        {
            cin >> x >> y;
            ve[y].push_back(x);
            in[x] ++;
            if( !x && !y )
                break;
        }
        for( int i =1 ; i<=n ; i++ )
        {
            if( !in[i] )
            {
                z = i;
                break;
            }
        }    
        dfs(z);
        cout << max( dp[z][0] , dp[z][1] ) << endl;
    }
    return 0;
}

看了discuss里面一个人的滚动数组写法 很有感触

因为这边每个结点只需要利用与它直接相连的后驱结点的信息 所以我们可以用滚动数组优化

要注意的是arr数组 必须写在函数内 使它变成局部变量

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int size = 6010;
vector<int>ve[size];
int val[size];
int dp[2] = {0,0};
int in[size];

void dfs( int u )
{
    int arr[2] = {0,0};
    int Size = ve[u].size();
    for( int i = 0 ; i<Size ; i++ )
    {
        dfs( ve[u][i] );
        arr[0] += max( dp[0] , dp[1] );
        arr[1] += dp[0];
    }
    dp[0] = arr[0];
    dp[1] = arr[1] + val[u];
}

int main()
{
    cin.sync_with_stdio(false);
    int n , x , y , z , sum;
    while( cin >> n )
    {
        sum = 0;
        memset( in , 0 , sizeof(in) );
        for( int i = 1 ; i<=n ; i++ )
        {
            cin >> val[i];
            ve[i].clear();
        }
        while(1)
        {
            cin >> x >> y;
            ve[y].push_back(x);
            in[x] ++;
            if( !x && !y )
                break;
        }
        for( int i =1 ; i<=n ; i++ )
        {
            if( !in[i] )
            {
                z = i;
                break;
            }
        }    
        dfs(z);
        cout << max(dp[0],dp[1]) << endl;
    }
    return 0;
}

他还写了种 多叉树 转2叉树后的写法 我感觉其实这个区别不算大吧..

但其实核心都是 开头提到的 状态转移方程

today:

　　听到一些事

　　明明和你不相关

　　但是能在心理拐几个弯的想到你