分组背包+树形DP（BY LPX）

最新推荐文章于 2020-12-05 15:01:23 发布
最新推荐文章于 2020-12-05 15:01:23 发布
阅读量528 收藏
点赞数
分类专栏： DP LPX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010761825/article/details/9347261
版权
LPX 同时被 2 个专栏收录
6 篇文章 0 订阅
订阅专栏
DP
1 篇文章 0 订阅
订阅专栏

专题传送门：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=24217#overview

A.POJ 1155

/*
类型：树形DP
题意：广播一场比赛，有发射站和用户，用户为叶子节点。每个发射站有消耗，到达用户有收益，现在问在不赔钱的情况下怎样使用户最大
思路：dp[i][j] 为给第i个节点分配k个用户的收益（可以为负），显然使dp[1][j]为正的最大j为所求
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>

#define maxn 3100
#define maxm 1100
#define INF (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

struct EDGE{
    int v,w;
    };

bool cmp1(EDGE a,EDGE b)
{
    return a.w > b.w;
}

int dp[maxn][maxn],
    val[maxn],
    son[maxn];
vector <EDGE> links[maxn];

int dfs1(int k)
{
    int i,mm;
    mm = links[k].size();
    if (mm == 0) son[k] = 1;
    else son[k] = 0;
    for(i = 0;i < mm;i++)
        son[k] += dfs1(links[k][i].v);
    return son[k];
}

void dfs2(int k)
{
    //printf("%dxxx\n",k);
    int mm = links[k].size(),
        i,ii,jj,now_limt = 0;

    dp[k][0] = 0;
    if (mm == 0) {
        dp[k][1] = val[k];
        }
    for(i = 0;i < mm;i++)
        dfs2(links[k][i].v);
    for(i = 0;i < mm;i++) //分组背包，枚举组
        for(ii = (now_limt += son[links[k][i].v]);ii >= 1;ii--)
            for(jj = 1;jj <= ii && jj <= son[links[k][i].v];jj++)
                dp[k][ii] = Max(dp[k][ii],dp[k][ii-jj] + dp[links[k][i].v][jj] - links[k][i].w);
    //
    //printf("%d:\n",k);for(i = 1;i <= son[k];i++) printf("%d ",dp[k][i]);printf("\n");
    return ;
}

int Work()
{
    int n,m,tran,i,j,t;
    EDGE tmp;
    scanf("%d%d",&n,&m);
    for(i = 0;i < maxn;i++)
        for(j = 0;j < maxn;j++)
            dp[i][j] = -INF;
    Clear(son,0);
    tran = n - m;
    for(i = 1;i <= tran;i++) {
        scanf("%d",&t);
        for(j = 1;j <= t;j++){
            scanf("%d%d",&tmp.v,&tmp.w);
            links[i].push_back(tmp);
            }
        //sort(links[i].begin(),links[i].end(),cmp1);
        }
    for(;i <= n;i++)
        scanf("%d",&val[i]);
    dfs1(1);                    //第一遍DFS统计每个点的子树的点数
    //for(i = 1;i <= n;i++)
    //    printf("%d_%d\n",i,son[i]);
    dfs2(1);                    //第二遍DFS开始DP
   // for(i = 1;i <= m;i++)
   //     printf("%d %d\n",i,dp[1][i]);
    int ans = m;
    while(dp[1][ans] < 0) ans--;
    printf("%d\n",ans);
    return 0;
}

int main()
{
    //freopen("test.in","r",stdin);
    Work();
    return 0;
}

B. HDU 1011 

/*
类型：树形DP
题意：一个虫子巢穴为树形结构，每个房间都有一些虫子和一定的概率存在脑虫。现在给你一定的战士，1战士可以消灭20个虫子，让你使打到脑虫的可能性最大
思路：dp[i][j]代表打i子树要j战士时的最大可能
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>

#define maxn 210
#define maxm 110
#define INF (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

int m;
int dp[maxn][maxn],bug[maxn],sum_bug[maxn],boss[maxn];
vector <int> edge[maxn];

void dfs2(int k,int fa)
{
    //printf("%d\n",k);
    int mm = edge[k].size(),i,ii,jj;

    for(i = 0;i < mm;i++)
        if (edge[k][i] != fa)
            dfs2(edge[k][i],k);

    //if ((mm == 1 && fa > 0) || mm == 0)
    //    if (bug[k] <= m) dp[k][bug[k]] = boss[k];
    for(i = bug[k];i <= m;i++) dp[k][i] = boss[k];
    for(i = 0;i < mm;i++)
        if (edge[k][i] != fa){
            for(ii = m;ii >= bug[k];ii--)
                for(jj = 1;jj <= ii-bug[k];jj++)
                    dp[k][ii] = Max(dp[k][ii],dp[k][ii-jj] + dp[edge[k][i]][jj]);
            }
    //printf("%d: %d\n",k,boss[k]);
    //for(i = 0;i <= sum_bug[k];i++) printf("%d ",dp[k][i]);printf("\n");
    return ;
}

int Work()
{
    int n,i,tmp_u,tmp_v;
    scanf("%d%d",&n,&m);
    if (n == -1) return 0;

    for(i = 1;i <= n;i++)
        edge[i].clear();
    Clear(dp,0);
    Clear(sum_bug,0);
    Clear(bug,0);

    for(i = 1;i <= n;i++)
        scanf("%d%d",&bug[i],&boss[i]),bug[i] = (bug[i] + 19) / 20;
    //for(i = 1;i <= n;i++)   printf("%d ",bug[i]);printf("\n");
    for(i = 1;i < n;i++){
        scanf("%d%d",&tmp_u,&tmp_v);
        edge[tmp_u].push_back(tmp_v);
        edge[tmp_v].push_back(tmp_u);
        }

    if (m == 0) {
        printf("0\n");
        return 1;
        }

    dfs2(1,0);

    printf("%d\n",dp[1][m]);
    return 1;
}

int main()
{
    //freopen("test.in","r",stdin);
    while(Work());
    return 0;
}
//END

C. POJ 1947 

/*
类型：树形DP
题意：给出一棵树,问最少切断几条边可以得到有p个结点的子树
思路：dp[i][j]代表第i个点为根的子树要得到j个节点的子树最少切多少个边
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>

#define maxn 200
#define maxm 1100
#define INF (1000000)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

int p,ans;
int dp[maxn][maxn];
vector <int> edge[maxn];

void dfs(int k)
{
    int mm = edge[k].size(),
        i,ii,jj;

    if (k == 1) dp[k][1] = mm;
    else dp[k][1]  = mm + 1;
    dp[k][0] = 1;

    for(i = 0;i < mm;i++) {
        dfs(edge[k][i]);
        for(ii = p;ii >= 1;ii--)
            for(jj = 1;jj <= ii-1;jj++)
                dp[k][ii] = Min(dp[k][ii],dp[k][ii-jj] + dp[edge[k][i]][jj] - 2);
        }
    //printf("%3d:",k);for(i = 0;i <= p;i++) printf("%9d",dp[k][i]);printf("\n");
    if (dp[k][p] < ans) ans = dp[k][p];
    return ;
}

int Work()
{
    int n,i,fa,son,j;
    scanf("%d%d",&n,&p);
    for(i = 0;i <= n;i++)
        for(j = 0;j <= p;j++)
            dp[i][j] = INF;
    for(i = 1;i < n;i++) {
        scanf("%d%d",&fa,&son);
        edge[fa].push_back(son);
        }
    ans = INF;
    dfs(1);
    printf("%d\n",ans);
    return 0;
}

int main()
{
    //freopen("test.in","r",stdin);
    Work();
    return 0;
}

//END

D. HDU 1561 

/*
类型：树形DP
题意：取M个城堡，使那啥最大
思路：不说了，桑心
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>

#define maxn 250
#define maxm 1100
#define INF (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

int n,m;
int dp[maxn][maxn],val[maxn];
vector <int> son[maxn];

void dfs(int k)
{
    int mm = son[k].size(),
        i,ii,jj;
    dp[k][1] = val[k];

    for(i = 0;i < mm;i++) {
        dfs(son[k][i]);
        for(ii = m;ii >= 1;ii--)
            for(jj = 0;jj <= ii-1;jj++)
                dp[k][ii] = Max(dp[k][ii],dp[k][ii-jj] + dp[son[k][i]][jj]);
        }
    //printf("%d: ",k);for(i = 0;i <= n;i++) printf("%d ",dp[k][i]);printf("\n");
    return ;
}

int Work()
{
    int a,b,i;
    scanf("%d%d",&n,&m);
    if (n == 0) return 0;
    m++;

    Clear(dp,0);
    Clear(val,0);

    for(i = 0;i <= n;i++)
        son[i].clear();
    for(i=  1;i <= n;i++){
        scanf("%d%d",&a,&val[i]);
        son[a].push_back(i);
        }
    //for(i = 1;i <= n;i++) printf("%d ",val[i]);printf("\n");
    dfs(0);
    printf("%d\n",dp[0][m]);
    return 1;
}

int main()
{
   // freopen("test.in","r",stdin);
    while(Work());
    return 0;
}
//END

E. HDU 1561 

/*
类型：树形DP
题意：给出一棵树,投放K个机器人，问使全部点都被走过的情况下机器人走的总路程和最小。
思路：dp[i][j]代表第i个点为根的子树要得到j个节点的子树最少切多少个边
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>

#define maxn 11000
#define maxm 12
#define INF (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

struct EDGE{
    int ed,w;
    } tmp;

int n,k;
int dp[maxn][maxm];
vector <EDGE> edge[maxn];

void dfs(int now,int fa)
{
    int mm = edge[now].size(),
        i,ii,jj,next;

    for(i = 0;i < mm;i++)
        if (edge[now][i].ed != fa) {
            next = edge[now][i].ed;
            dfs(next,now);

            for(ii = k;ii >= 0;ii--) {
                dp[now][ii] += dp[next][0] + edge[now][i].w * 2;
                for(jj = 0;jj <= ii;jj++)
                    dp[now][ii] = Min(dp[now][ii],dp[now][ii-jj] + dp[next][jj] + edge[now][i].w * jj);
                }
            }
    return ;
}

int Work()
{
    int i,j,s,u,v,w;
    if (scanf("%d%d%d",&n,&s,&k) == EOF) return 0;
    for(i = 1;i <= n;i++) edge[i].clear();
    Clear(dp,0);
    for(i = 1;i < n;i++) {
        scanf("%d%d%d",&u,&v,&w);
        tmp.w = w;
        tmp.ed = v;
        edge[u].push_back(tmp);
        tmp.ed = u;
        edge[v].push_back(tmp);
        }
    dfs(s,0);
    printf("%d\n",dp[s][k]);
    return 1;
}

int main()
{
    //freopen("test.in","r",stdin);
    while(Work());
    return 0;
}

F. POJ 2486

/*
树形DP
题意：一颗树上吃苹果，每个点上都有一定的苹果
思路：状态dp[i][j][k]表示为第i个点走j步，k为0代表不回，k为1代表回则有三种转移，见代码。
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>
#include<math.h>

#define maxn 110
#define maxm 210
#define INF (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN
int k,n;
int apple[maxn],
    dp[maxn][maxm][2];
vector<int>edge[maxn];

void dfs(int x,int fa)
{
    int mm,i,j,jj,son;
    //0-不回 1-回
    mm = edge[x].size();
    for(i = 0;i < mm;i++)
        if (edge[x][i] != fa)
            dfs(edge[x][i],x);
    for (j = 0;j <= k;j++)
        dp[x][j][1] = dp[x][j][0] = apple[x];
    for(i = 0;i < mm;i++)
        if ((son = edge[x][i]) != fa)
            for(j = k;j >= 0;j--) //又他妈傻逼了！！！！！！
                for(jj = 0;jj <= j;jj++) {
                    if (jj >= 2) dp[x][j][0] = Max(dp[x][j][0],dp[x][j-jj][0]+dp[son][jj-2][1]);
                    if (jj >= 1) dp[x][j][0] = Max(dp[x][j][0],dp[x][j-jj][1]+dp[son][jj-1][0]);
                    if (jj >= 2) dp[x][j][1] = Max(dp[x][j][1],dp[x][j-jj][1]+dp[son][jj-2][1]);
                    }
    return ;
}

int Work()
{
    int i,u,v;
    if (scanf("%d%d",&n,&k) == EOF) return 0;
    Clear(dp,0);
    Clear(apple,0);
    for(i = 1;i <= n;i++) scanf("%d",&apple[i]);
    for(i = 1;i <= n;i++) edge[i].clear();
    for(i = 1;i < n;i++) {
        scanf("%d%d",&u,&v);
        edge[u].push_back(v);
        edge[v].push_back(u);
        }
    dfs(1,0);
    printf("%d\n",dp[1][k][0]);
}

int main()
{
    //freopen("test.in","r",stdin);
    while(Work());
    return 0;
}


//END

J. HDU 4276 

/*
树形DP
题意：
思路：
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<algorithm>
#include<math.h>

#define maxn 110
#define maxm 510
#define OO (1 << 28)
#define TP int
#define LL long long
#define DB double
#define Mid(x) ((x) >> 1)
#define Lc(x) ((x) << 1)
#define Rc(x) (((x) << 1)|1)
#define Clear(a,b) memset(a,b,sizeof(a))

using namespace std;

inline TP Max(TP a,TP b)
{
    if (a > b) return a;
    return b;
}

inline TP Min(TP a,TP b)
{
    if (a > b) return b;
    return a;
}

bool cmp(TP a,TP b)
{
    return a < b;
}

//BEGIN

struct EDGE{
    int ed,cost;
    } tmp;

vector<EDGE>edge[maxn];

int n,t;
int dp[maxn][maxm],gold[maxn];

int dfs_find(int now,int fa)
{
    int mm,i,time;
    if (now == n) return 0;
    mm = edge[now].size();
    for(i = 0;i < mm;i++)
        if (edge[now][i].ed != fa) {
            time = dfs_find(edge[now][i].ed,now) + edge[now][i].cost;
            if (time >= 0) {
                    edge[now][i].cost = 0;
                    return time;
                    }
            }
    return -OO;
}

void dfs(int now,int fa)
{
    int mm,i,son,cost,j,jj;
    mm = edge[now].size();
    for(j = 0;j <= t;j++) dp[now][j] = gold[now];
    for(i = 0;i < mm;i++)
        if (edge[now][i].ed != fa) {
            son = edge[now][i].ed;
            dfs(son,now);
            cost = edge[now][i].cost;
            for(j = t;j >= 0;j--)
                for(jj = cost*2;jj <= j;jj++)
                    dp[now][j] = Max(dp[now][j] , dp[now][j-jj] + dp[son][jj-cost*2]);
            }
    return ;
}

int Work()
{
    int i,u,v,w;
    if (scanf("%d%d",&n,&t) == EOF) return 0;
    Clear(dp,0);
    Clear(gold,0);
    for(i = 1;i <= n;i++)
        edge[i].clear();
    for(i = 1;i < n;i++) {
        scanf("%d%d%d",&u,&v,&w);
        tmp.cost = w;
        tmp.ed = u;
        edge[v].push_back(tmp);
        tmp.ed = v;
        edge[u].push_back(tmp);
        }
    for(i = 1;i <= n;i++)
        scanf("%d",&gold[i]);
    t -= dfs_find(1,0);
    //printf("%dXXX\n",t);
    if (t <= 0) {
        printf("Human beings die in pursuit of wealth, and birds die in pursuit of food!\n");
        return 1;
        }
    dfs(1,0);
    printf("%d\n",dp[1][t]);
    return 1;
}


int main()
{
    //freopen("test.in","r",stdin);
    while(Work());
    return 0;
}


//END


u010761825
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有依赖的背包问题(树形dp+分组背包)
Mr_Kingk的博客
01-31 650
有N个物品和一个容量是V的背包。 物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。 如下图所示： 如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。 每件物品的编号是i，体积是vi，价值是wi，依赖的父节点编号是pi。物品的下标范围是1…N。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总...
树形dp(树形背包, 二次扫描和换根法)
CK1513710764的博客
04-01 706
树是特殊的无环连通图,有n个节点以及n - 1条边(可以是有向边也可以是无向边). 树形dp则是基于树这个数据结构的动态规划问题. 树分为有向树和无向树.有向树只要储存每个节点的子节点即可.而无向树则用邻接表的形式进行储存.注意无向树在遍历的时候遍历过的节点(状态)要打上标记,防止重复遍历. 在树上设计dp算法时,一般以节点从深到浅(子树从小到大)的顺序作为dp的"阶段".dp的状态表示中,一般第一维是节点编号(表示以该节点为根的子树). 我们有两种方式实现动态规划(对应两种遍历树的方式).分别是递
Vijos1676 陶陶吃苹果（树形dp）
Coco_T的博客
03-18 341
题目链接 分析： 好好读题啊 如果一个点被保留，那么这个点到根路径上的点都会被保留，前辈说这是：树形依赖问题 解决树形依赖问题的常见做法就是将父节点的值给当前节点，然后用当前节点继续深层的计算 设f[i][j]f[i][j]f[i][j]表示在结点iii到根结点的链一侧选择jjj个结点的最大收益 f[son]=f[x]f[son]=f[x]f[son]=f[x]，然后用递归后的f[...
POJ--2486--Apple Tree--树形回溯DP
WoniuGe
03-23 492
反思：在写代码的过程中，尽量使代码的行为符合实际的逻辑，避免出现与实际逻辑无关甚至相违背的代码，尽管这些代码看上去不是那么的重要，但这是十分隐蔽的Bug. 参考题解：点击打开链接 这是典型的回溯型树状dp。dp[i][j][0]代表以i为根节点的子树最多j步后回到i能吃到的最多的苹果，dp[i][j][1]代表以i为根节点的子树最多j步后不回到i节点最多能吃到的子树。那么状态转移就分三
leetcode 847. 访问所有节点的最短路径（连通图中访问所有节点需要的最小遍数 巨水bfs）
m0_43602209的博客
12-05 331
题目 假如这是树，就好了，可以直接 树形dp。与树形背包dp 吃苹果和 让机器人去走很像。 可惜这只是一个普通的联通图而已。 class Solution { public: int vis[1<<13][13]; struct node{ int sta,x,step; }; int shortestPathLength(vector<vector<int>>& graph) { int n=gr
HF-LPX30系列 低功耗小尺寸Wi-Fi模组用户手册
11-28
《HF-LPX30系列低功耗小尺寸Wi-Fi模组用户手册》是上海汉枫电子科技有限公司为开发者提供的一款详尽的技术指南，主要针对HF-LPX30系列的Wi-Fi模块。该系列模组以其小巧的体积和低功耗特性，特别适合于嵌入式智能产品...
Examples.zip_94766Wcm_lpx-347_matlab_ridgelet_voyagedk2
07-14
The Matlab script file ridgelet.m (see he folder ./examples/radon) contains an example of denoising by hard thresholding the discrete ridgelet coefficients of a ...
lpx_links:获取Logic Pro X的其他内容下载链接
05-10
lpx_links lpx_links是获取Logic Pro X的其他样本/声音内容的直接下载链接的实用程序。 它获取最新链接 创建一个包含所有链接的文本文件。 将链接文件导入到FireFox的DownThemAll插件之类的下载管理器中应该可以...
LPX摄谱有助于痕量分析
02-06
【LPX摄谱技术及其在痕量分析中的应用】 LPX摄谱，即激光等离子体X射线光谱（Laser-Induced Plasma X-ray Spectroscopy），是一种利用高功率激光激发微小目标产生等离子体，进而分析其中元素成分及含量的痕量分析...
leetcode下载-lpx:像素
06-29
树 图 查找 《剑指Offer》 《程序员面试金典》 《LeetCode》 《程序员代码面试指南(左程云)》 第四部分 第五部分 第六部分 有任何问题欢迎联系： 欢迎关注我的知乎账号： 微信公众号： 幼稚园老大哥 微博账号： 已...
2020暑期牛客多校训练营第九场（B）Groundhog and Apple Tree(树形dp，贪心)
s260127ljy的博客
08-09 435
Groundhog and Apple Tree 原题请看这里 题目描述： 土拨鼠非常擅长爬树。 一天，土拨鼠来到一棵苹果树上。出于某种原因，他决定吃掉树上的所有苹果。苹果树上有n{n}n个点，每个点上都有一个苹果。这些点由n−1{n-1}n−1条边连接（所有点都被连接）。在每个边上都有一个障碍物，这需要一定的HPHPHP才能让GroundhogGroundhogGroundhog跳过。如果GroundhogGroundhogGroundhog吃了ith{i ^ {th }}ith在树上的苹果，他可以恢复a
树形DP
weixin_33753845的博客
03-23 78
题目 Ghost Blows Light TELE Rebuidling Roads Bribing FIPA Apple Tree Contestants Division 思路 1. 树形 DP 动规数组的设置方法一般为 dp[u][i], u 为根节点, i 为可枚举的量(资源, 收益都有可能) 2. 树形 DP 一般都是多叉树转二叉树, 若孩子节点之间的地位...
poj 2486 树形dp(吃苹果)
dearmango
08-28 523
题意：给定一颗有n个顶点的树，每个点上有，求从1出发，走V步，最多能遍历到的权值
【树形DP】17.2.6 T4 苹果树 题解
It's Maverick.
02-06 524
题目描述： jyb 有一天梦见自己变成了一只萌萌的苹果虫。 jyb 作为一只虫的时间只有t 小时，之后他就去作茧化蝶，在这t 小时内，他需要在苹果树上尽可能多地吃苹果。 苹果树可以看做一棵有n 个节点n-1 条边的树，每个节点有ai 个苹果，jyb每爬过一条边需要1 小时的时间，吃苹果时间忽略不计。jyb 在每一个小时内可以原地休息，也可以在一条树枝上来回爬。 现在jyb 从1 号点开始爬，
树形背包DP的两种优化方式——vijos1676、codeforces815c
Sega_hsj 's Blog
03-08 1000
1.O(nm)——vijos1676陶陶吃苹果 背景 陶陶很喜欢吃苹果。 描述 curimit知道陶陶很喜欢吃苹果。于是curimit准备在陶陶生日的时候送给他一棵苹果树。 curimit准备了一棵这样的苹果树作为生日礼物：这棵苹果树有n个节点，每个节点上有c[i]个苹果，这棵树高度为h。 可是，当curimit把这棵树给陶陶看的时候，陶陶却说：“今年生日不收礼，收礼只收节点数减高...
POJ 2486 Apple Tree（树形dp）
I am a slow walker, but I never walk backwards!
06-21 697
题目的大体意思是：一个人
pear-admin-fast项目修改为集成PostgreSQL启动
07-15
pear-admin-fast项目修改为集成PostgreSQL的数据库备份（postgresql的数据结构备份）
Hadoop和Spark初学者指南：基础安装与实践应用 0基础！！易懂！！.html
最新发布
07-15
详细介绍了如何从基础安装到实践应用掌握Hadoop和Spark两大数据处理框架。文章首先概述了Hadoop和Spark的定义与功能，然后详细描述了环境准备，包括Java和Python的安装。接着，文章分步骤指导如何下载、安装及配置Hadoop和Spark，并通过示例展示了如何进行基本的操作和任务处理，如在Hadoop上上传和读取文件，在Spark上执行Word Count任务。此外，指南还提供了常见问题的解决方案，并建议了进一步学习的方向，帮助读者深入理解和高效应用这两款工具。本文适合初学者，旨在帮助他们快速上手并掌握大数据处理的基本技能。 Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoop和Spark初学者指南Hadoo
最新网站ASP与SQL的课程报告.doc
07-15
数据库
LPX-00225: end-element tag "br" does not match start-element tag "DummyFragment"
07-28
它指示在结束标签`</br>`中的元素标签与开始标签`<DummyFragment>`不匹配。 这种错误通常发生在以下几种情况下： 1. 在开始标签中有一个拼写错误或者标签名不匹配。 2. 在结束标签中有一个拼写错误或者标签名不匹配...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值