poj 1947 树形dp

最新推荐文章于 2020-12-02 23:22:11 发布

GDUT_练意

最新推荐文章于 2020-12-02 23:22:11 发布

阅读量274

点赞数

分类专栏：动态规划

动态规划专栏收录该内容

14 篇文章

订阅专栏

本文探讨了动态规划(DP)算法中的一个具体优化方法，通过调整状态转移方程减少重复计算，提高效率。针对子问题的重叠性质，采用自底向上方式避免冗余运算，并详细展示了实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

别人的思路

for(int j=n-1;j>=0;j--){
            for(int k=1;k<=n-j;k++){
              dp[rt][j+k]=min(dp[rt][j+k],dp[rt][j]+dp[son][k]-1);
             }
          }

因为j 是递减的, 更新后的 dp[rt][j+k]，没有机会成为 dp[rt][j]，所有计算过程不影响原始计算需要的数据
这一点，在递推中经常遇到
我一开始好像是这样想的 . 首先关于那个初值的问题，dp[i][1]到底应该是多少，是i的所有孩子，还是i的所有孩子加上父亲。然后是dp[i][0]它的初值应该是多少。
一开始列的状态方程式 dp[rt][j]<-tem[j]= min{dp[rt][j-k]+dp[son][k]-1,tem[j] }….
j,k的枚举范围繁琐。。。

  for(int i=head[rt];i!=-1;i=edge[i].next)
     son=edge[i].to;
     dfs(son)
     num[rt]+=num[son]
     for(j=0;j<n;j++) tem[j]=dp[rt][j];.....

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<cmath>
#include<iostream>
using namespace std;
typedef int ll;
const ll inf=0x3f3f3f3f;
const long long maxn=200;

int  n,m;
int head[maxn];
int tot;
void init(){
    memset(head,-1,sizeof(head));
    tot=0;
}
struct Edge{
    int to,next;
}edge[maxn*2];
void addedge(int u,int v){
    edge[tot].to=v; //edge[tot].w=w;
    edge[tot].next=head[u]; head[u]=tot++;
}
int num[maxn];
int tem[maxn];
int dp[maxn][maxn];
int du[maxn];
void dfs(int rt){
      for(int i=head[rt];i!=-1;i=edge[i].next){
         int son=edge[i].to;
         dfs(son);
          for(int j=n-1;j>=0;j--){
            for(int k=1;k<=n-j;k++){
              dp[rt][j+k]=min(dp[rt][j+k],dp[rt][j]+dp[son][k]-1);
             }
          }
      }
}
int father[maxn];
int main()
{
   //freopen("D://in.txt","r",stdin);
    while(scanf("%d%d",&n,&m)!=EOF){
        int u,v;
        init();
        memset(du,0,sizeof(du));
        memset(father,0,sizeof(father));
        for(int ik=1;ik<n;ik++){
             scanf("%d%d",&u,&v);
             addedge(u,v);
             du[u]++;
             father[v]=u;
        }
        int rt=1;
        while(father[rt]!=0){
              rt=father[rt];
        }
        for(int i=0;i<=n;i++){
            for(int j=0;j<=n;j++){
              dp[i][j]=inf;
            }
            dp[i][1]=du[i];
        }
        dfs(rt);
        int res=dp[rt][m];
        for(int i=1;i<=n;i++){
            if(dp[i][m]<res){
             res=dp[i][m]+1;
            }
        }
        printf("%d\n",res);
    }
    return 0;
}