POJ 1848 树形DP

题目链接

题意：

给一颗树可以在树上添加一些边使得这颗树内的点都有且仅有在一个环内，求添加的最小边数，若无解输出-1

思路：

定义DP数组：

dp[u][0]：表示以u为根的子树包括根节点在内都在某一环内的最小添边数

dp[u][1]：表示以u为根的子树除根节点以外的点都在某一环内的最小添边数

dp[u][2]：表示以u为根的子树除根节点和某一树链外其余点都在某一环内的最小添边数

状态转移： 定义一个sum变量，表示所有子树的dp[v][0]和

对于dp[u][0]可以通过遍历所有子树的dp[v][2]获得，即树链末尾的点连边向根

方程：dp[u][0] = max ( dp[u][0] , sum-dp[v][0]+dp[v][2]+1 );

对于dp[u][0]可以通过遍历所有子树中选两条链获得，即将两条链的末尾连接起来

方程：dp[u][0] = max ( dp[u][0] , sum-dp[v1][0]-dp[v2][0]+min( dp[v1][1] , dp[v1][2] )+min( dp[v2][1] , dp[v2][2] )+1 );

对于dp[u][1]就是sum变量，但是需要稍微缩小一下，防止爆int

方程：dp[u][1] = min ( sum , inf );

对于dp[u][2]可以通过遍历所有子树选取某一子树的dp[v][1]或dp[v][2]获得，即将根节点融入链中

方程：dp[u][2] = min ( dp[u][2] , sum-dp[v][0]+min( dp[v][1] , dp[v][2] ) );

C++代码：

#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<queue>
#include<vector>
#include<string>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 110;
const int maxm = 210;
const int inf  = 10010;

int n,tol,head[maxn];
struct edge
{
    int to,next;
}es[maxm];

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

int dp[maxn][3];

void dfs( int u , int f )
{
    int sum = 0;
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to;
        if ( v!=f )
        {
            dfs ( v , u ); sum += dp[v][0];
        }
    }
    dp[u][0] = inf;
    dp[u][1] = min( sum , inf );
    dp[u][2] = inf;
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to;
        if ( v!=f )
        {
            dp[u][2] = min( dp[u][2] , sum-dp[v][0]+min( dp[v][1] , dp[v][2] ) );
            dp[u][0] = min( dp[u][0] , sum-dp[v][0]+dp[v][2]+1 );
        }
    }
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        for ( int j=es[i].next ; j!=-1 ; j=es[j].next )
        {
            int v1 = es[i].to;
            int v2 = es[j].to;
            if ( v1!=f&&v2!=f )
                dp[u][0] = min( dp[u][0] , sum-dp[v1][0]-dp[v2][0]+min( dp[v1][1] , dp[v1][2] )+min( dp[v2][1] , dp[v2][2] )+1 );
        }
    }
}

int main()
{
    while( scanf ( "%d" , &n )==1 )
    {
        tol = 0;
        memset ( head , -1 , sizeof(head) );
        for ( int i=1 ; i<n ; i++ )
        {
            int u,v;
            scanf ( "%d%d" , &u , &v );
            addedge( u , v );
            addedge( v , u );
        }
        dfs ( 1 , 0 );
        if ( dp[1][0]>=inf )
            printf ( "-1\n" );
        else
            printf ( "%d\n" , dp[1][0] );
    }
    return 0;
}