POJ 1848 树形DP

最新推荐文章于 2019-07-23 10:57:19 发布

原创最新推荐文章于 2019-07-23 10:57:19 发布 · 248 阅读

1 ·

CC 4.0 BY-SA版权

树形DP 专栏收录该内容

25 篇文章

订阅专栏

本文介绍了一种使用树形动态规划（DP）解决特定树结构问题的方法，通过定义三种状态来实现对树中各节点的最优解计算，并提供了详细的C++代码实现。

题目链接

题意：

给一颗树可以在树上添加一些边使得这颗树内的点都有且仅有在一个环内，求添加的最小边数，若无解输出-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;
}