树形DP(HDOJ1011 2196 4003 5148 POJ2342)

最新推荐文章于 2019-08-30 21:39:00 发布

bnmjmz

最新推荐文章于 2019-08-30 21:39:00 发布

阅读量1.5k

点赞数 1

分类专栏：学习

本文链接：https://blog.csdn.net/bnmjmz/article/details/41019671

版权

学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

自己整理了个比较水的模版...一般简单的树形DP题基本可以解....

用HDOJ 4003举例

题目大意：给一棵树，以及每人通过此边的花费，求用给定人数遍历树的最小花费

输入点数,根位置,人数

始边,终边,每人通过此边的花费

输出用给定人数遍历树的最小花费

注意：人可以往回走,用dp[p][0]记录

状态转移方程:

dp[p][j]=min(dp[p][j],dp[p][j-k]+dp[son][k]+k*dv[p][i].cos)

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int MAXN = 10010;
const int MAXM = 11;
int n,m,root;
int dp[MAXN][MAXM];
struct Edge{
    int next,cos;
    Edge();
    Edge(int b,int c){next=b;cos=c;}
};
vector<Edge>dv[MAXN];
void init()
{
    for(int i=0;i<=n;i++) dv[i].clear();
    memset(dp,0,sizeof(dp));
}
void dfs(int p,int fa)
{
    int son;
    for(int i=0;i<dv[p].size();i++)
    {
        son=dv[p][i].next;
        if(son^fa){//不往回走
            dfs(son,p);
            for(int j=m;j>=0;j--)//使用j人搜索父亲(需要用到更小j的记录,循环不可反)
            {
                dp[p][j]+=dp[son][0]+2*dv[p][i].cos;//初始为可能的最大值消费
                for(int k=1;k<=j;k++)//使用k人搜索t孩子,j-k人搜索其他孩子(循环可反)
                {
                    dp[p][j]=min(dp[p][j],dp[p][j-k]+dp[son][k]+k*dv[p][i].cos);
                }
            }
        }
    }
}
int main()
{
#ifdef DEBUG
   freopen("CBin.txt","r",stdin);
   //freopen("CBout.txt","w",stdout);
#endif
    while(~scanf("%d%d%d",&n,&root,&m))
    {
        if(n==-1&&m==-1)break;
        init();
        for(int i=1;i<n;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            dv[a].push_back(Edge(b,c));
            dv[b].push_back(Edge(a,c));
        }
        //int root=1;
        dfs(root,0);
        printf("%d\n",dp[root][m]);
    }
    return 0;
}

HDOJ 1011

题目大意：给一棵树，点消耗，点价值，求用这些人获得的最大价值，根位置默认1

输入点数,人数

过该点消耗的人数（每20一人）,点价值

始边,终边

输出分配这些人,输出获得的最大价值

注意：有人经过的区域才能得到该点的价值,即使该点花费为0人

状态转移方程:

dp[p][j]=max(dp[p][j],dp[p][j-k]+dp[son][k])

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int MAXN = 110;
int n,m;
int dp[MAXN][MAXN],cos[MAXN],w[MAXN];
struct Edge{
    int next;
    Edge();
    Edge(int b){next=b;}
};
vector<Edge>dv[MAXN];
void init()
{
    for(int i=0;i<=n;i++) dv[i].clear();
    memset(dp,0,sizeof(dp));
	memset(cos,0,sizeof(cos));
	memset(w,0,sizeof(w));
}
void dfs(int p,int fa)
{
    int son;
    int t=(cos[p]+19)/20;//攻打消费
    for(int i=t;i<=m;i++) dp[p][i]=w[p];
    for(int i=0;i<dv[p].size();i++)
    {
        son=dv[p][i].next;
        if(son^fa){
            dfs(son,p);
            for(int j=m;j>=t;j--)//使用j打父亲(需要用到更小j的记录,循环不可反)
            {
                for(int k=1;k<=j-t;k++)//使用k打t孩子,j-k打其他孩子(循环可反)
                    dp[p][j]=max(dp[p][j],dp[p][j-k]+dp[son][k]);
            }
        }
    }
}
int main()
{
#ifdef DEBUG
   freopen("CBin.txt","r",stdin);
   //freopen("CBout.txt","w",stdout);
#endif
    while(~scanf("%d%d",&n,&m))
    {
        if(n==-1&&m==-1)break;
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",cos+i,w+i);
        }
        for(int i=1;i<n;i++)
        {
            int b,c;
            scanf("%d%d",&b,&c);
            dv[b].push_back(Edge(c));
            dv[c].push_back(Edge(b));
        }
        if(m==0){printf("0\n");continue;}
        int root=1;
        dfs(root,0);
        printf("%d\n",dp[1][m]);
    }
    return 0;
}

HDOJ 2196

题目大意：略

输入边终点,权,边起点默认为编号+1

输出所有的,点到各点的路径最大权

这代码也可以求树的直径

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int MAXN = 10010;
int n,e,s,m;
int dx[MAXN],dy[MAXN];
struct Edge{
    int next,w;
    Edge();
    Edge(int a,int b){next=a;w=b;}
};
vector<Edge>dv[MAXN];
void init()
{
    for(int i=0;i<=n;i++) dv[i].clear();
    memset(dx,0,sizeof(dx));
    memset(dy,0,sizeof(dy));
}
void dfs(int p,int fa,int *d)
{
    int son;
    for(int i=0;i<dv[p].size();i++)
    {
        son=dv[p][i].next;
        if(son^fa){
            d[son]=d[p]+dv[p][i].w;
            dfs(son,p,d);
        }
    }
}
int main()
{
#ifdef DEBUG
   freopen("CBin.txt","r",stdin);
   //freopen("CBout.txt","w",stdout);
#endif
    while(~scanf("%d",&n))
    {
        init();
        for(int a=2;a<=n;a++)
        {
            int b,c;
            scanf("%d%d",&b,&c);
            dv[a].push_back(Edge(b,c));
            dv[b].push_back(Edge(a,c));
        }

        dfs(1,0,dx);//任意一个起点dx[1]=0
        int x,y;

        x=1;
        for(int i=2;i<=n;i++)
        {
            if(dx[i]>dx[x]) x=i;
        }

        memset(dx,0,sizeof(dx));
        dfs(x,0,dx);//距离1节点最远的节点x作为起点

        y=1;
        for(int i=2;i<=n;i++)
        {
            if(dx[i]>dx[y]) y=i;
        }
        dfs(y,0,dy);//距离x节点最远的节点y作为起点,xy为树的直径

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

POJ2342

题目大意：给一棵树，点权，父亲孩子不能同时出现，求树的最大权

输入点数,点权,边
输出独立集最大权

状态转移方程:
dp[node][1] += dp[i][0];//选父亲,不选孩子
dp[node][0] +=max(dp[i][1],dp[i][0]);//不选父亲,不选孩子

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int MAXN = 10010;
int n,e,s,m;
int dp[MAXN][2];
struct Edge{
    int next;
    Edge();
    Edge(int b){next=b;}
};
vector<Edge>dv[MAXN];
void init()
{
    for(int i=0;i<=n;i++) dv[i].clear();
    memset(dp,0,sizeof(dp));
}
void dfs(int p,int fa)
{
    int son;
    for(int i=0;i<dv[p].size();i++)
    {
        son=dv[p][i].next;
        if(son^fa){
            dfs(son,p);
            dp[p][1] += dp[son][0];
            dp[p][0] +=max(dp[son][1],dp[son][0]);
        }
    }
}
int main()
{
#ifdef DEBUG
   freopen("CBin.txt","r",stdin);
   //freopen("CBout.txt","w",stdout);
#endif
    while(~scanf("%d",&n))
    {
        if(!n)continue;
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&dp[i][1]);
        }
        for(int i=1;i<n;i++)
        {
            int b,c;
            scanf("%d%d",&b,&c);
            dv[b].push_back(Edge(c));
            dv[c].push_back(Edge(b));
        }
        int root=1;//任意选一个起点
        dfs(root,0);
        printf("%d\n",max(dp[root][0],dp[root][1]));
    }
    return 0;
}

HDOJ5148
输入点数,选择的点数
始边,终边,边权
输出选择的点两两直接的总距离和乘2

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
const int MAXN = 2005;
#define INF 999999999999LL
typedef long long LL;
int n,m,k;
LL dp[MAXN][55];//dp[p][k]代表节点p的k-1个后代之间两两的距离总和
struct Edge{
    int next,cos;
    Edge();
    Edge(int b,int c){next=b;cos=c;}
};
vector<Edge>dv[MAXN];
void init()
{
    for(int i = 1;i <= n;i++)
    {
        dv[i].clear();
        dp[i][0] = 0;//1个节点没距离可言
        for(int j = 1;j <= k;j++)
        {
            dp[i][j] = INF;
        }
    }
}
void dfs(int p,int fa)
{
    int son;
    for(int b=0;b<dv[p].size();b++)
    {
        son=dv[p][b].next;
        if(son^fa){
            dfs(son,p);
            for(int i=k-1;i>=1;i--)//下发i个
            {
                for(int j=1;j<=i;j++){//该子节点分配到j个
                    if(dp[p][i-j]==INF||dp[son][j-1] == INF)continue;
                    dp[p][i]=min(dp[p][i],dp[p][i-j]+dp[son][j-1]+dv[p][b].cos*(k-j)*(j));//dp[son][j-1]注意j要减1
                }
            }
        }
    }
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        scanf("%d%d",&n,&k);
        init();
        for(int i=1;i<n;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            dv[a].push_back(Edge(b,c));
            dv[b].push_back(Edge(a,c));
        }
        LL ans=INF;
        dfs(1,0);
        for(int i = 1;i <= n;i++)//不一定包含根节点
        {
            ans = min(ans,dp[i][k-1]);
        }
        cout<<ans*2<<'\n';
    }
    return 0;
}