树状DP专辑（持续更新）

最新推荐文章于 2024-04-06 21:40:24 发布
最新推荐文章于 2024-04-06 21:40:24 发布
阅读量3.6k 收藏 4
点赞数 2
分类专栏： Dynamic Programming 文章标签： struct ini c tree 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geniusluzh/article/details/6912721
版权

POJ 1655 Balancing Act 简单树状DP

http://poj.org/problem?id=1655

这道题目题意是说，任意删除树中的一个点，那么被分成几棵树之后，子树中点数最大的值就是该点的balance，求具有最小Balance的点。

我们用num[i]表示以i为根节点的子树所包含的点的个数，那么该点的balance就是最大那个num[i]值了，比较简单，要是不会就看看代码吧，这道题很简单！

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#define INF 1000000000
#define MAX 20020
using namespace std;
int adj[MAX];
int value[MAX];
typedef struct EDGE
{
    int v,next;
}Edge;
Edge edge[MAX<<1];
int edgeNum;

void AddEdge(int u,int v)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}

bool vis[MAX];
int num[MAX],dp[MAX],n;

int dfs(int u)
{
    int ans=0,sum=0;
    vis[u]=true;
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!vis[v])
        {
            int t=dfs(v);
            sum+=t;
            if(ans<t)
                ans=t;
        }
    }
    num[u]=sum+1;
    int t = n-num[u];
    if(t>ans)
        ans=t;
    dp[u]=ans;
    return num[u];
}

int main()
{
    int T;
    int a,b;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        memset(adj,-1,sizeof(adj));
        edgeNum=0;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            AddEdge(a,b);
        }
        memset(vis,false,sizeof(vis));
        dfs(1);
        int ans = INF,index;
        for(int i=1;i<=n;i++)
        {
            if(ans>dp[i])
            {
                ans=dp[i];
                index=i;
            }
        }
        printf("%d %d\n",index,ans);
    }
    return 0;
}



POJ 2378 Tree Cutting

        这道题题意就是说给你一棵树，然后通过删除一个点之后，与该点相连的边都被删除，那么这个时候形成了新的分开的快，要使的所有的块中的点的个数不大于n/2删点方法。

        简单树状dp，我们使用dp[i]表示以i为根的子树（包括i自己）的节点的个数，于是我们看删除点i的时候就是要每一个孩子节点包含的子树都满足条件，然后父亲节点特判一下就行了。

        代码比较简单，看一下就行了。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
const int Max=10100;
int adj[Max],edgeNum,fa[Max],dp[Max];
typedef struct EDGE
{
    int v,next;
}Edge;
Edge edge[2*Max];
void Init()
{
    memset(adj,-1,sizeof(adj));
    edgeNum=0;
}
void AddEdge(int u,int v)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}
int vis[Max];
void InitDp(int u)
{
    dp[u]=1;
    vis[u]=1;
    for(int j=adj[u];j!=-1;j=edge[j].next)
    {
        int v=edge[j].v;
        if(vis[v]==0)
        {
            fa[v]=u;
            InitDp(v);
            dp[u]+=dp[v];
        }
    }
}

void Solve(int n)
{
    int flag;
    int num=0;
    for(int i=1;i<=n;i++)
    {
        flag=1;
        for(int j=adj[i];j!=-1;j=edge[j].next)
        {
            int v=edge[j].v;
            int t;
            if(fa[i]==v)
                t=n-dp[i];
            else
                t=dp[v];
            if(t>(n/2))
            {
                flag=0;
                break;
            }
        }
        if(flag)
        {
            num++;
            printf("%d\n",i);
        }
    }
    if(num==0)
        printf("NONE\n");
}

int main()
{
    int n,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        Init();
        for(int i=1;i<n;i++)
        {
            scanf("%d %d",&a,&b);
            AddEdge(a,b);
        }
        memset(vis,0,sizeof(vis));
        InitDp(1);
        Solve(n);
    }
    return 0;
}


POJ 1192 最优连通子集

http://poj.org/problem?id=1192

这道题的意思就是说给你一棵树，然后每个点有个权值，让你求一棵子树使得这棵子树所包含的点的权值之和最大。

那么这道题明显是一道比较简单的树状DP，我们定义value[i]表示以点i为根节点的子树的最大权值之和，那么转移的过程就和给你一个序列，求最大的子序列的和是一样的，具体的转移过程见代码。

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#define INF 1000000000
#define MAX 1010
using namespace std;
int adj[MAX];
int value[MAX];
typedef struct EDGE
{
    int v,next;
}Edge;
Edge edge[MAX<<1];
int edgeNum;

void AddEdge(int u,int v)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}

typedef struct POINT
{
    int x,y;
}Point;
Point point[MAX];
bool IsConnect(Point a,Point b)
{
    if(abs(a.x-b.x)+abs(a.y-b.y)==1)
        return true;
    else
        return false;
}

bool vis[MAX];

int dfs(int u)
{
    int ans = 0;
    vis[u]=true;
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(vis[v]==false)
        {
            int t = dfs(v);
            if(t>0)
                ans+=t;
        }
    }
    value[u]+=ans;
    return value[u];
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        memset(adj,-1,sizeof(adj));
        edgeNum=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d",&point[i].x,&point[i].y,&value[i]);
        }
        for(int i=0;i<n;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                if(IsConnect(point[i],point[j]))
                {
                    AddEdge(i,j);
                }
            }
        }
        memset(vis,false,sizeof(vis));
        dfs(0);
        int ans = -INF;
        for(int i=0;i<n;i++)
        {
            if(ans<value[i])
                ans=value[i];
        }
        printf("%d\n",ans);
    }
    return 0;
}

POJ 1155 TELE

http://poj.org/problem?id=1155

我们定义状态为dp[u][j]表示以u为根节点的子树所提供给j个叶子节点信号的时候的最大的收益值，那么这个时候的转移就有点想背包了，反正比较好写。这要是一开始没有想到要这样定义状态。如果还是不知道怎么转移的话，请看我的代码：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#define INF 1000000000
#define MAX 3030
using namespace std;
int adj[MAX];
int value[MAX];
typedef struct EDGE
{
    int v,c,next;
}Edge;
Edge edge[MAX<<1];
int edgeNum;

void AddEdge(int u,int v,int c)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],edge[edgeNum].c=c,adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],edge[edgeNum].c=c,adj[v]=edgeNum++;
}

bool vis[MAX];
int l,r;
vector<int> dp[MAX];
int tdp[MAX];
vector<int> Get(vector<int> a,vector<int> b)
{
    int aLen=a.size(),bLen=b.size();
    tdp[0]=0;
    for(int i=1;i<=aLen+bLen;i++)
        tdp[i]=-INF;
    for(int i=0;i<aLen;i++)
    {
        for(int j=0;j<bLen;j++)
        {
            tdp[i+j]=max(a[i]+b[j],tdp[i+j]);
        }
    }
    vector<int> ans;
    for(int i=0;i<=aLen+bLen-2;i++)
        ans.push_back(tdp[i]);
    return ans;
}

vector<int> dfs(int u)
{
    if(u>=l&&u<=r)
    {
        dp[u].push_back(0);
        dp[u].push_back(value[u]);
        return dp[u];
    }
    vis[u]=true;
    dp[u].push_back(0);
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        int c=edge[i].c;
        if(vis[v]==false)
        {
            vector<int> temp=dfs(v);
            for(int i=1;i<temp.size();i++)
                temp[i]-=c;
            dp[u]=Get(dp[u],temp);

        }
    }
    return dp[u];
}

int main()
{
    int n,m;
    int a,b;
    int k;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(adj,-1,sizeof(adj));
        memset(vis,false,sizeof(vis));
        memset(value,0,sizeof(value));
        for(int i=1;i<=n;i++)
            dp[i].clear();

        edgeNum=0;
        l=n-m+1,r=n;
        for(int i=1;i<=n-m;i++)
        {
            scanf("%d",&k);
            while(k--)
            {
                scanf("%d%d",&a,&b);
                AddEdge(i,a,b);
            }
        }
        for(int i=n-m+1;i<=n;i++)
            scanf("%d",&value[i]);
        dp[1] = dfs(1);
        int len=dp[1].size();
        int ans;
        for(int i=len-1;i>=0;i--)
        {
            if(dp[1][i]>=0)
            {
                ans=i;
                break;
            }
        }
        printf("%d\n",ans);

    }
    return 0;
}


POJ 1849 Two

http://poj.org/problem?id=1849

这道题是要求两个人走完一棵树所走的最短的距离，那么这个最短的距离就是整棵树的边权的和的两倍剪掉以任意一个节点为根的子树所包含的最大值和次大值，这点想想就能明白。还要注意的一点就是，一个点所表示的最大值和次大值不能来之于同一棵子树，这个只要在向上更新的时候小心一点就行了。

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <algorithm>
#define MAX 100100
using namespace std;

int adj[MAX];
typedef struct EDGE
{
    int v,c,next;
}Edge;
Edge edge[MAX<<1];
int edgeNum;
int glAns,dp[MAX][2];

bool vis[MAX];

void AddEdge(int u,int v,int c)
{
    edge[edgeNum].v=v,edge[edgeNum].c=c,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].c=c,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}

typedef struct NODE
{
    int id,v;
    NODE(){}
    NODE(int tid,int tv)
    {
        id=tid,v=tv;
    }
}Node;

bool cmp(Node x,Node y)
{
    if(x.v>y.v)
        return true;
    else
        return false;
}

int * dfs(int u)
{
    vis[u]=true;
    vector<Node> q;
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        int c=edge[i].c;
        if(!vis[v])
        {
            int *t;
            t=dfs(v);
            t[0]+=c;
            if(t[1]>0)
                t[1]+=c;
            q.push_back(Node(v,t[0]));
            q.push_back(Node(v,t[1]));
        }
    }
    sort(q.begin(),q.end(),cmp);
    if(q.size()>0)
    {
        dp[u][0]=q[0].v;
        for(int i=1;i<q.size();i++)
        {
            if(q[i].id!=q[0].id)
            {
                dp[u][1]=q[i].v;
                break;
            }
        }
    }
    //printf("u %d %d %d\n",u,dp[u][0],dp[u][1]);
    if(dp[u][0]+dp[u][1]>glAns)
        glAns=dp[u][0]+dp[u][1];
    return dp[u];
}

int main()
{
    int n,m;
    int a,b,c;
    int sum;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(adj,-1,sizeof(adj));
        edgeNum=0;
        memset(dp,0,sizeof(dp));
        glAns=0;
        memset(vis,false,sizeof(vis));
        sum=0;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            sum+=(c<<1);
            AddEdge(a,b,c);
        }
        dfs(m);
        //printf("%d %d\n",sum,glAns);
        printf("%d\n",sum-glAns);
    }
    return 0;
}


ZOJ 3201 Tree of Tree

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3326

这道题是说给你一棵树，每一棵树有一个点权，让你求一棵只有k个节点的子树，使得总的权值之和最大。

我们定义dp[u][i]表示以u为根节点，一共包含i个节点时候的最大权值，那么这个时候就成了背包问题了，只要从子节点逐个的更新父亲节点就行了。但是有一点需要注意，就是我们定义的是以u为根节点的子树，那么我们在之前的更新所选的点是任意的进行背包，最后再加上当前这个u节点进行更新，最后求出一个任意节点为根的时候的k个节点的子树的最大值就行了。

具体见代码：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#define MAX 110
using namespace std;
typedef struct EDGE
{
    int v,next;
}Edge;
Edge edge[MAX<<1];
int adj[MAX],edgeNum;
int value[MAX];
vector<int> dp[MAX];
bool vis[MAX];
void AddEdge(int u,int v)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}

int mid[MAX];
vector<int> Update(vector<int> a,vector<int> b)
{
    int aLen=a.size(),bLen=b.size();
    memset(mid,0,sizeof(mid));
    for(int i=0;i<bLen;i++)
    {
        for(int j=0;j<aLen;j++)
        {
            mid[i+j]=max(mid[i+j],b[i]+a[j]);
        }
    }
    vector<int> ans;
    for(int i=0;i<=aLen+bLen-2;i++)
        ans.push_back(mid[i]);
    return ans;
}

vector<int> dfs(int u)
{
    vis[u]=true;
    dp[u].push_back(0);
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!vis[v])
        {
            vector<int> t=dfs(v);
            dp[u]=Update(dp[u],t);
        }
    }
    for(int i=0;i<dp[u].size();i++)
    {
        dp[u][i]+=value[u];
    }
    dp[u].insert(dp[u].begin(),0);
    return dp[u];
}

int main()
{
    int n,k;
    int a,b;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d",&value[i]);
            dp[i].clear();
        }

        memset(adj,-1,sizeof(adj));
        memset(vis,false,sizeof(vis));
        edgeNum=0;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            AddEdge(a,b);
        }
        dfs(0);
        int ans = 0;
        for(int i=0;i<n;i++)
        {
            if(dp[i].size()>k)
            {
                ans = max(ans,dp[i][k]);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

HDU 1011 Starship Troopers

http://acm.hdu.edu.cn/showproblem.php?pid=1011

这道题题意很坑爹，感觉很戳。从根节点往下可以分成好几路走，还有就是要从一个子节点取到Brain至少要有一个Trooper下去，也就是说要从1开始往上转移，不能是0.注意这两点点就可以了，还有就是m为0的时候输出0，如果按照真实游戏的情况，还是可以理解清楚题意的，不过还是有点坑爹。

具体见代码：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#define MAX 110
using namespace std;
int N;
typedef struct EDGE
{
    int v,next;
}Edge;
Edge edge[MAX<<1];
int adj[MAX],edgeNum;
int value[MAX],c[MAX];
int dp[MAX][MAX];
int glAns;
bool vis[MAX];
void AddEdge(int u,int v)
{
    edge[edgeNum].v=v,edge[edgeNum].next=adj[u],adj[u]=edgeNum++;
    edge[edgeNum].v=u,edge[edgeNum].next=adj[v],adj[v]=edgeNum++;
}

int Get(int v)
{
    if(v%20==0)
        return v/=20;
    else
        return v/20+1;
}

void dfs(int u)
{
    vis[u]=true;
    memset(dp[u],0,sizeof(dp[u]));
    for(int i=adj[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!vis[v])
        {
            dfs(v);
            for(int j=N;j>=0;j--)
            {
                for(int k=1;k<=j;k++)
                {
                    dp[u][j]=max(dp[u][j],dp[u][j-k]+dp[v][k]);
                }
            }
        }
    }
    for(int i=N;i>=c[u];i--)
        dp[u][i]=dp[u][i-c[u]]+value[u];
    for(int i=0;i<c[u];i++)
        dp[u][i]=0;
}

int main()
{
    int n,m;
    int a,b;
    while(scanf("%d%d",&n,&m))
    {
        if(n==-1&&m==-1)
            break;
        N=m;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&c[i],&value[i]);
            c[i]=Get(c[i]);
        }

        memset(adj,-1,sizeof(adj));
        memset(vis,false,sizeof(vis));
        edgeNum=0;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            AddEdge(a,b);
        }
        if(m==0)
        {
            printf("0\n");
            continue;
        }
        dfs(1);
        printf("%d\n",dp[1][N]);
    }
    return 0;
}


小小程序师
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【树形DP】树形DP入门详解+例题剖析
繁凡さん的博客
04-06 1万+
树形DP 树形DP准确的说是一种DP的思想，将DP建立在树状结构的基础上。整体的思路大致就是用树形的结构存储数据。 要学树形DP之前肯定是要先学会树和图的呀，至少先学会链式前向星，不会的话可以看一下我之前写的博客 链接：【图论】图，实现图（三种方式），二分图 详解 树形DP的关键和实现方法是dfsdfsdfs。 先找到树根，从树根开始运用 dfsdfsdfs 递归，跟dfsdfsdfs一样先初始化...
树形DP-我的学习笔记
最新发布
05-17
就是赚个积分啊
动态规划——树形dp
qq_57150526的博客
01-03 2649
树形 DP，即在树上进行的 DP。由于树固有的递归性质，树形 DP 一般都是递归进行的。在树上设计动态规划算法时，一般就以节点从深到浅（子树从小到大）的顺序作为DP的“阶段”，DP的状态表示中，第一维通常是节点编号（代表以该节点为根的子树）。自底向上dfs，属于树的后序遍历
【算法笔记】树形DP算法总结&详解
天生我材必有用，千金散尽还复来。
08-12 9490
树形DP，又称树状DP，即在树上进行的DP，是DP（动态规划）算法中较为复杂的一种。本文将以例题+算法的形式，详细讲解这种算法。
动态规划之树形DP
小L的博客
08-01 1892
本文主要讨论动态规划中的一种常见应用——树形DP。树形DP通常应用于树状结构的问题中，通过从叶子节点到根节点的动态规划过程，计算出每个节点的状态值，并最终得出问题的解。文章将介绍树形DP的基本思想、常用解法和优化技巧，并给出实例说明。通过本文的学习，读者将对树形DP有一个更深入的理解，能够更好地应用于实际问题解决中。
树形dp（超详细）
盛楠的博客
08-11 8784
通常，我们从根节点出发，向子节点做深度优先搜索，并由其子节点的最优解合并得到该节点的最优解。有些问题，我们还需再次从根节点出发，向子节点做深度优先搜索，对于树上的每个节点（除根节点外），由父节点的信息（父节点合并后的信息，除去该孩子的信息，就是其与孩子的信息）更新该节点的信息 例题1 给出一个n个节点的树，找出一个节点为根，使得树上所有节点的深度之和最大 我们先假设1号节点就是根节点，这时候，我们对树做一次dfs就可以求出每个点的子树的大小，并且同时也可以求出所有节点的深度之和 这时候，如果我们把根
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
概率dp 树形dp经典题目加解析
04-28
概率dp 树形dp经典题目加解析........高斯求期望...............
树状dp
shi_zi_183的博客
08-18 1942
树状dp 在树结构上做dp，常见的题型是：给出一棵树，让你实现最小代价或找到最大收益。 树这种结构本身具有“子结构”具有递归性，所以非常适合进行dp。 基于树的解题步骤一般是：先把树转为有根树（如果是几个互不连通的树，就加一个虚拟根，它连接所有孤立的树），然后在树上做DFS，递归到最底层的叶子节点，再一层层返回信息更新至根结点。显然，树上的DP所操作的就是这一层层返回的信息。不同的题目需要灵活设计不同的DP状态和转移方程。 树形dp的基本操作 先看一个简单的入门题。通过这一题，了解树的存储，以及如何在树上设
算法：树形dp（树状dp）
m0_63997099的博客
04-06 2337
树状dp的基本概念 和 模板题
算法套路十九——树形DP
Pistachiout的学习博客
06-04 1872
树形 DP，即在树上进行的 DP。由于树固有的递归性质，这里的DP是指是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法，故虽然带有DP，但一般都是通过来进行。
动态规划入门（七） 树状DP详解
Hello World!
02-07 559
简而言之是dfs里的动态规划，在深搜过程中动态规划最优解，而树就分为枝叶，由根深搜到枝叶末端。树状dp特点（呈树形发散状）是...
树形DP总结
ZhuRanCheng的博客
04-05 446
树形DP总结
什么是树形DP？
xmz12300的博客
07-02 315
在树形DP中，我们通过定义状态和状态转移方程，来解决一些与树相关的问题，比如最长路径、最小路径覆盖等等。首先初始化当前节点的大小为1，表示节点本身的大小，然后遍历当前节点的所有孩子节点，并递归地计算它们的子树大小。下面是一个简单的树形DP算法示例，用C++实现，它解决的问题是对于一个有根树，计算树的重心和子树大小。下面是两个 C++ 实现树形 DP 的例子，其中以计算以节点 1 为根节点的树的最长路径为例。，即除了当前节点子树以外的大小，比较出该节点的重心。即为以节点 1 为根节点的树的最长路径。
动态规划（树形dp）
dzy521的博客
07-04 726
#### 四、树形dp ##### （一）、基础 树形$dp$是在树的$dfs$中进行$dp$， 在树形$dp$中，我们动态规划的过程大概就是先递归访问所有子树，再在根上合并，我们求解的往往是所有的在子树范围内的最优解 ##### （二）、例题 1、子树大小 （1）、题意：计算每个点的子树的大小 （2）、题解： 状态表示：$sz[u]$代表$u$为根的子树大小 状态转移：$sz[u]=1+\sum sz[v]$，指本节点的子树大小等于子节点的所有子树大小之和加一 ```cpp int sz
树形DP简介
龙进的博客
06-13 3705
树形dp就是在树上进行的dp。由于树具有递归的性质，因此树形dp一半都是用递归的方式进行的。 问题的大意是，选了父节点，那么它的直接子节点就不能被选择，求总的权值的最大值。 题目：P1352 没有上司的舞会 这题是树形dp的板子题，每个节点都有被选择和不被选择两种情况。 用数组dp[n][0]记录第n个节点不被选择的情况，用数组dp[n][1]记录被选择的情况。 那么就有状态转移方程 dp[n][0] = Σ(max(dp[x][0],dp[x][1])，其中，x是n的所有子节点 dp[n
树形DP
nameofcsdn的博客
01-24 1719
目录 一，树形DP 二，OJ实战 CSU 1022: 菜鸟和大牛 SCU-1114 数字三角 HDU - 2032杨辉三角 CSU 1010: Water Drinking 一，树形DP 以树作为动态规划的良基集合的问题，称为树形DP 二，OJ实战 CSU 1022: 菜鸟和大牛 题目： Description blue和AutoGerk是好朋友。他们的相同点是都喜欢研究算法，不同点是AutoGerk已是大牛而blue还是菜鸟。blue经常拿一些自以为很难的问题去问Aut...
树形DP与状态压缩DP解析
"陈益波在2011年华中科大的ACM暑期集训中讲解了状态压缩DP和树型...状态压缩DP和树型DP是动态规划中高效处理复杂状态空间和树形结构问题的利器，通过理解和掌握这些技术，能够解决一些在传统方法下难以求解的复杂问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值