树形DP

 ① 相邻节点不能同时选时

　　所得到权值最大：POJ2342 

#include <iostream>
#include <string.h>
#include <cstdio>
#include <math.h>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 6005;
const int maxk = 2e6+5;



int father[maxn], happy[maxn];
bool vis[maxn];
int dp[maxn][2];        //dp[i][0]，dp[i][1]表示i不去或去产生的最大价值
int N, R;

int find( int r )
{
    vis[r] = 1;


    for( int i = 1; i <= N; i++ )
        if ( !vis[i] && father[i] == r )
        {
            find(i);
            dp[r][1] += dp[i][0];
            dp[r][0] += Max(dp[i][1],dp[i][0]);
        }
    return Max( dp[r][1], dp[r][0] );
} 

void read()
{
    memset( vis, 0, sizeof(vis) );
    cin >> N;
    int x, y;

    for ( int i = 1; i <= N; i++ )
        scanf( "%d", &happy[i] );
    for ( int i = 1; i < N; i++ )
    {
        scanf( "%d %d", &x, &y );
        father[x] = y;
        //son[y] = x;
        R = y;
    }
    cin >> x >> y;

    for( int i = 1; i <= N; i++ )
        dp[i][1] = happy[i];
}


int main()
{
    read();
    
    cout << find(R) << endl;

    return 0;
}

　　所得到权值最小：POJ1463，其实并不是最小..具体要求看题目

#include <iostream>
#include <string.h>
#include <cstdio>
#include <string>
#include <math.h>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 2000;
const int maxk = 2e6+5;

int dp[maxn][2], father[maxn];
int N, ans;
bool vis[maxn];
string road;

int find( int r )
{
    vis[r] = true;

    for ( int i = 0; i < N; i++ )
        if ( !vis[i] && father[i] == r )
        {
            find(i);
            dp[r][1] += Min( dp[i][0], dp[i][1] );
            dp[r][0] += dp[i][1];
        }
    return Min( dp[r][0], dp[r][1] );
}

void init()
{
    ans = 0;
    memset( dp, 0, sizeof(dp) );
    memset( vis, 0, sizeof(vis) );
    memset( father, -1, sizeof(father) );
    
    int u, v, num;
    
    for ( int j = 1; j <= N; j++ )
    {
        scanf( "%d:(%d)", &u, &num );
        for ( ; num; num-- )
        {
            scanf("%d", &v);
            father[v] = u;
        }
    }


    for ( int i = 0; i < N; i++ )
        dp[i][1] = 1;
}

int main()
{
    while ( ~scanf("%d", &N ) )
    {
        init();
        
        for ( int i = 0; i < N; i++ )
            if ( !(father[i]+1) ) 
                ans += find(i);

        cout << ans << endl;
    }
    return 0;
}

 　　在基环树上取得的值最大: 基环树是指N个节点N条边的“树”，可见其上必然有环，但是删除环上任意一条边后可变成树，所以做法相比与上两题就是先求出环，把环所在的一条边删掉，再在树上做DP，这道题坑爹的是没说所有点是连通的，所以需要把答案加起来

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <math.h>
#include <string>
#include <map>
#include <algorithm>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline LL LMax(LL a,LL b) { return a>b?a:b; }
inline LL LMin(LL a,LL b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 1e6+5;
const int maxk = 200;
const int mod = 100000000;

struct node {
    int next, to;
}e[maxn<<1];

int head[maxn], val[maxn];
LL dp[2][maxn];
bool vis[maxn];
int cnt, N;
int nopass, ringP1, ringP2;

void addedge( int u, int v ) 
{
    e[cnt].to = v; e[cnt].next = head[u]; head[u] = cnt++;
    e[cnt].to = u; e[cnt].next = head[v]; head[v] = cnt++;
}

void init()
{
    cnt = 0;
    memset( head, -1, sizeof(head) );
    memset( vis, 0, sizeof(vis) );
}

void getDp( int t, int pre )
{
    dp[0][t] = 0; dp[1][t] = val[t];
    
    for ( int i = head[t]; i+1; i = e[i].next )
    {
        if ( e[i].to == pre ) continue;
        if ( i == nopass || i == (nopass^1) ) continue;

        getDp( e[i].to, t );
        dp[0][t] += LMax( dp[1][e[i].to], dp[0][e[i].to] );
        dp[1][t] += dp[0][e[i].to];
    }
}

void dfs( int t, int pre ) 
{
    vis[t] = true;

    for ( int i = head[t]; i+1; i = e[i].next )
    {
        int tmp = e[i].to;

        if ( tmp == pre ) continue;
        if ( !vis[tmp] ) dfs( tmp, t );
        else
        {    //不是父亲，又没被遍历过，说明是环的一部分
            nopass = i;
            ringP1 = tmp; ringP2 = t; 
        }
    }
}

int main()
{
    init();
    cin >> N;

    int x;
    for ( int i = 1; i <= N; i++ )
        { scanf("%d %d", &val[i], &x ); addedge(x,i); }

    LL tmp, ans = 0;

    for ( int i = 1; i <= N; i++ )
    {
        if (vis[i]) continue;

        dfs(i, -1);
        getDp( ringP1, -1 );
        tmp = dp[0][ringP1];
        
        getDp( ringP2, -1 );
        ans += LMax( tmp, dp[0][ringP2] );
    }

    printf("%lld
",ans);
    return 0;
}

② 去掉一个点

　　POJ2378:去掉一个点后剩下的连通分量中节点个数小于等于N/2，问这样的点有多少个（感觉并没有dp啊...完全就是dfs嘛）

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <string>
#include <algorithm>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 1e4+5;
const int maxk = 2e6+5;

struct node {
    int to, next;
}e[2*maxn];

int N, cnt;
int sum[maxn], dp[maxn], linjie[maxn];
//dp[i]表示去掉i后，i的儿子形成的连通分量中，最多的节点个数
//sum[i]表示包括i及从i往下走的所有节点数
bool vis[maxn];
vector<int> ans;

void addedges( int u, int v )
{
    e[cnt].to = v; e[cnt].next = linjie[u]; linjie[u] = cnt++;
    e[cnt].to = u; e[cnt].next = linjie[v]; linjie[v] = cnt++;
}

int find( int r )
{
    int tmp, v, mmax = 0;
    sum[r]++;
    vis[r] = true;
    
    for ( int i = linjie[r]; i+1; i = e[i].next )
        if ( !vis[e[i].to] )
        {
            v = e[i].to;
            tmp = find(v);

            mmax = Max(mmax, tmp);
            sum[r] += tmp;
        }
    dp[r] = mmax;

    if ( r != 1 )
        if ( dp[r] <= N/2 && N-sum[r] <= N/2 )
            ans.push_back(r);

    return sum[r];
}

void init()
{
    cin >> N;
    cnt = 0;
    memset( vis, 0, sizeof(vis) );
    memset( linjie, -1, sizeof(linjie) );
}

int main()
{
    init();

    int x, y;
    for ( int i = 1; i < N; i++ )
    {
        scanf( "%d %d", &x, &y );
        addedges(x,y);
    }

    find(1);
    if ( dp[1] <= N/2 )
        ans.push_back(1);

    sort( ans.begin(), ans.end() );

    if ( ans.empty() )
        cout << "NONE" << endl;
    else
        for ( vector<int>::iterator it = ans.begin(); it!=ans.end(); it++ )
            cout << (*it) << endl;
    return 0;
}