无向图问题（树形dp）

最新推荐文章于 2022-11-19 21:37:53 发布
最新推荐文章于 2022-11-19 21:37:53 发布
阅读量572 收藏
点赞数 1
分类专栏： 算法二
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1_s2_c3_/article/details/102214793
版权

文章来自：https://www.cnblogs.com/seaupnice/p/9471700.html

例一：
一个树，每个点有一个“快乐”值，父子结点不能同时快乐，问这个结构的最大快乐值。

分析：
dp[i][0]:表示不邀请i员工其子树达到的最大快乐值，dp[i][1]则表示邀请。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
#define mst(s, t) memset(s, t, sizeof(s))
const int INF = 0x3f3f3f3f;
const int maxn = 6010;
vector<int> G[maxn];
int father[maxn], dp[maxn][2];
void dfs(int root){
    for(int i=0; i<G[root].size(); i++){
        dfs(G[root][i]);
    }
    for(int i=0; i<G[root].size(); i++){
        dp[root][0] += max(dp[G[root][i]][0], dp[G[root][i]][1]);
        dp[root][1] += dp[G[root][i]][0];
    }
}
int main() 
{
    freopen("in.txt", "r", stdin);
    mst(dp, 0); mst(father, -1);
    int n;
    scanf("%d", &n);
    for(int i=1; i<=n; i++){
        scanf("%d", &dp[i][1]);
        G[i].clear();
    }
    int fa, so;
    while(scanf("%d%d", &so, &fa) && fa && so){
        G[fa].push_back(so);
        father[so] = fa;
    }
    int root = 1;
    while(father[root] != -1)    root=father[root];
    dfs(root);
    printf("%d\n", max(dp[root][0], dp[root][1]));
    return 0;
}

例二
现在要在一棵树上布置士兵，每个士兵在结点上，每个士兵可以守护其结点直接相连的全部边，问最少需要布置多少个士兵。

分析：
1 dp[root][0] += dp[G[root][i]][1];
2 dp[root][1] += min(dp[G[root][i]][0], dp[G[root][i]][1]);

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
#define mst(s, t) memset(s, t, sizeof(s))
const int INF = 0x3f3f3f3f;
const int maxn = 1510;
int dp[maxn][2], father[maxn];
vector<int> G[maxn];
void dfs(int root){
    for(int i=0; i<G[root].size(); i++){
        dfs(G[root][i]);
    }
    for(int i=0; i<G[root].size(); i++){
        dp[root][0] += dp[G[root][i]][1];
        dp[root][1] += min(dp[G[root][i]][0], dp[G[root][i]][1]);
    }
}
int main() 
{
    //freopen("in.txt", "r", stdin);
    int n;
    while( scanf("%d", &n) != EOF){
        for(int i=0; i<=n; i++){
            G[i].clear();
            dp[i][1] = 1,  dp[i][0] = 0;
            father[i] = -1;
        }
        for(int i=0; i<n; i++){
            int root, node, cnt;
            scanf("%d:(%d)",&root, &cnt);
            for(int i=0; i<cnt; i++){
                scanf("%d", &node);
                G[root].push_back(node);
                father[node] = root;
            }
        }
        int root = 1;
        while(father[root] != -1) root=father[root];
        dfs(root);
        printf("%d\n", min(dp[root][0], dp[root][1]));
    }
    return 0;
}

例三：
一棵无向树，结点为n(<=10,000)，删除哪些结点可以使得新图中每一棵树结点小于n/2。

分析：
在遍历树的过程中，访问每个node，维护两个值：

所有子树的结点数的最大值childmax
所有子树(这里包括node)的结点数之和sum。
递归过程中用上一层的sum，不断更新这一层的childmax。

而childmax和sum则共同用来判断这个node是否可以删除。

下面再分析判断条件： childmax<=n/2 && n-sum<=n/2

childmax<=n/2 ：去掉node后，原先node的子树均满足条件。

n-sum<=n/2 ：去掉node后，原先除node和node的所有子树外的树(就当是node的祖先树吧)均满足条件。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
#define mst(s, t) memset(s, t, sizeof(s))
const int INF = 0x3f3f3f3f;
const int maxn = 10010;
vector<int> G[maxn];
int ans[maxn], num, n;
int dfs(int node, int father){
    int sum = 1, childmax = 0;   //若是叶子结点则return sum=1，否则求其子树(包括自己)的总结点数
    for(int i=0; i<G[node].size(); i++){
        if(G[node][i] == father)continue; //因为是树结构，这里可以在无向时避免遍历成环 
        int sum_son = dfs(G[node][i], node);
        childmax = max(sum_son, childmax);//所有子树的结点数的最大值
        sum += sum_son;//sum:node的子树的结点数和
    }
    childmax = max(childmax, n-sum);
    if(childmax <= n/2){
        /*
         * 当node结点的孩子结点的结点数最大为Sum,若Sum<=n/2,则该点符合条件
         * 因为去掉node后，任意子树结点数<=n/2, max()保证其非子树结点和仍<=n/2
         * 故该点满足条件
        */
        ans[num++] = node;
    }
    return sum;
}
int main() 
{
    //freopen("in.txt", "r", stdin);
    scanf("%d", &n);
    for(int i=0; i<n-1; i++){
        int a, b;
        scanf("%d%d", &a, &b);
        G[a].push_back(b);
        G[b].push_back(a);
    }
    num = 0;
    int tmp = dfs(1, 0);
    //cout << n << "==" << tmp << endl; //验证
    sort(ans, ans+num);
    if(num){
        for(int i=0; i<num; i++){
            printf("%d\n", ans[i]);
        }
    }else{
        printf("NONE\n");
    }
    return 0;
}

例四：

题意：一棵结点带权树，大小(结点数)为k的子树的权值和最大为多少
分析：
这里对每个子节点进行背包dp， dp[j] = max(dp[j], dp[j-w[i]]+v[i]) ，从后往前dp是因为若从后往前会使v的某一个t被重复选取。

这道题整体思路还不清晰，要再多看看。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
#define mst(s, t) memset(s, t, sizeof(s))
const int INF = 0x3f3f3f3f;
const int maxn = 110;
vector<int> G[maxn];
int dp[maxn][maxn];  //dp[i][j]:node[i]结点数为j的子树的最大权值
int k, ans, cnt[maxn], weight[maxn];
int dfs(int node, int father){
    cnt[node] = 1;
    for(int i=0; i<G[node].size(); i++){
        if(G[node][i] == father) continue;
        cnt[node] += dfs(G[node][i], node);
    }
    dp[node][1] = weight[node];  
    //这里初始化不能在main()内  ？？ 
/*
 *  dp[node][j-t]是之前的子节点为根更新的子树产生的
 *  dp[v][t]是以当前子节点为根的子树产生的
 *  j如果顺序遍历，前面dp[node][j]的更新会影响后面的dp[node][j-t]，导致后面
 *更新dp[node][j]时是一当前子节点为根的子树产生的
*/
    for(int i = 0; i < G[node].size(); i++){
        int v = G[node][i];
        for(int j = cnt[node]; j >= 1; j--){
            for(int t = 0; t<j && t<=cnt[v]; t++){
                dp[node][j] = max(dp[node][j], dp[node][j-t]+dp[v][t]);
            }
        }
    }
    ans = max(ans, dp[node][k]);
    return cnt[node];
}
int main() 
{
    freopen("in.txt", "r", stdin);
    int n;
    while(scanf("%d%d",&n, &k) != EOF){
        mst(dp, 0);  ans = 0;
        for(int i=0; i<maxn; i++){
            G[i].clear();
        }
        for(int i=0; i<n; i++){
            scanf("%d", &weight[i]);
        }
        int a, b;
        for(int i = 1; i < n; i++){
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        dfs(0, -1);
        printf("%d\n", ans);
    }
    return 0;
}

例五：E - Cell Phone Network

题意：给n[1,10000]个点，n-1条边，树形结构，从n个点中取尽量少的点构成一个集合，使剩下所有点都能与这个集合中的部分点相连。

(这个概念叫最小支配集)

分析：
dp[u][]：以点u为根的被染色的点的个数

dp[u][0]:u不染色，父节点染色覆盖u min(1, 2)u不染色，不能覆盖子节点v，故要不v染色覆盖自己，要不v被v染色的子节点覆盖

dp[u][1]:u不染色，子节点存在被染色的覆盖u min(1,2)u不染色，所以子节点v不存在被染色的父亲；若所有v均不染色，此时u未被覆盖，故需要有一个v来染色，选择min(dp[v][2]-dp[v][1])即可。

dp[u][2]:u染色 min(0,1,2)+1 子节点v染不染色都可以；自己染色故需+1

/*
 * poj3659
 * 最小支配集:从所有顶点中取尽量少的点组成一个集合，
 *            使剩下的所有点都与取出来的所有点相连。
 * dp[u]:以点u为根的被染色的点的个数
 *  
 * dp[u][0]:u不染色，父节点染色覆盖u 
 * dp[u][1]:u不染色，子节点存在被染色的覆盖u 
 * dp[u][2]:u染色 
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 10010;
vector<int> G[maxn];
int dp[maxn][3], n;

void dfs(int u, int f){ 
    //叶子结点
    if(G[u].size()==1 && G[u][0]==f){
        dp[u][0] = 0; 
        dp[u][1] = inf; 
        dp[u][2] = 1;
        return;
    }
    int mini = inf, flag = 1;
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i];
        if(v == f) continue;
        dfs(v, u);
        dp[u][0] += min(dp[v][1], dp[v][2]);
        dp[u][2] += min(min(dp[v][0], dp[v][1]), dp[v][2]);
        if(dp[v][1] < dp[v][2]){
            dp[u][1] += dp[v][1];
            mini = min(mini, (dp[v][2] - dp[v][1]));
        }else{
            flag = 0;
            dp[u][1] += dp[v][2];
        } 

    }
    dp[u][2]++;   //u点需要染色 
    if(flag){
/*
 * 如果所有子节点dp[v][1]<dp[v][2],则所有子节点点不放,这时必须有一个孩子结点放才可以保证
 * u被覆盖 
*/ 
        dp[u][1] += mini;
    }     
}

int main(){
    //freopen("in.txt", "r", stdin);
    int n; scanf("%d", &n);
    for(int i=0; i<=n; i++)G[i].clear();
    for(int i=1; i<n; i++){
        int a, b; scanf("%d%d", &a, &b);
        G[a].push_back(b); G[b].push_back(a);
    }
    dfs(1, -1); 
    printf("%d\n", min(dp[1][1], dp[1][2]));
    //1是根,无父节点 
    return 0;
}

例六：F - Computer

题意：一棵边带权值的树，求每个点在树上的最远距离。

解题过程

1、dp：计算点v在树上的最远距离，通过dfs()寻找。v通过v的子树可以找到最远距离，v也可以通过v的父节点找到最远距离。通过子树找，向下遍历更新即可(即向下寻找)。通过父节点找，需要知道父节点的最远距离，父节点可以通过找自己的父节点获得最远距离(即一直向上寻找)，也可以通过寻找子树获得最远距离(但不能包含以v为根的子树(否则会重复))(即先向上后向下寻找)，这里就需要结点的次远距离(即该距离是不包含结点最远距离上的第一个结点的最远距离，故称为次远距离)。

/*
 * hdu2196
 * 
*/
#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn =  1e4+10;
struct edge{
    int to, val;
    edge(int a, int b) : to(a), val(b) {}
};
vector<edge> G[maxn];
int dp[3][maxn], id[maxn];
//树只有一个父亲，会有多个儿子 
//id[v]: v在v的子树中可以得到的最大距离，所经过的第一个孩子结点 
//dp[v][0]: v在v的所有子树中获得的最长距离 
//dp[v][1]: v的孩子的第二长距离
//dp[v][2]: v通过父亲获得的最长距离
void dfs1(int x, int f){
    for(int i=0; i<G[x].size(); i++){
        int to = G[x][i].to, w = G[x][i].val;
        if(to == f) continue;
        dfs1(to, x); 
        if(dp[0][x] < dp[0][to] + w){
            dp[0][x] = dp[0][to] + w;
            id[x] = to;   //记录点x的最大距离经过的第一个孩子结点 
        }
    }
    
    for(int i=0; i<G[x].size(); i++){
        int to = G[x][i].to, w = G[x][i].val;
        if(to == f) continue;
        if(id[x] == to) continue;  //找次大的 
        dp[1][x] = max(dp[1][x], w + dp[0][to]);
    }
}
void dfs2(int x, int f){
    for(int i=0; i<G[x].size(); i++){
        int to = G[x][i].to, w = G[x][i].val;
        if(to == f) continue;
        if(to == id[x]){
            dp[2][to] = max(dp[2][x], dp[1][x]) + w;
            //to是x的孩子:to的最大距离是 x不经过to的最大距离(即次大距离)[向下的]和
            //x向上的最大距离  的最大值 + dist(x,to) (画图理解)
            //这里的转移也是dp[v][1]和id[x]存在的意义 
        }else{ 
            dp[2][to] = max(dp[2][x], dp[0][x]) + w;
            //to不是x最大距离经过的点
            //则to的最大距离是dist(x,to)和x向上或向下的最大距离的最大值
        } 
        dfs2(to, x);
        //0和1子树的信息可以直接用,2也是步步更新,一直到最优 
    }
}
int main(){
    //freopen("in.txt", "r", stdin);
    int n;
    while(scanf("%d", &n) != EOF){
        memset(dp, 0, sizeof(dp)); 
        for(int i=1;i<=n;i++)G[i].clear();
        for(int i=2; i<=n; i++){
            int a, b; scanf("%d%d", &a, &b);
            G[i].push_back(edge(a, b));
            G[a].push_back(edge(i, b));
        }
        dfs1(1, -1);
        dfs2(1, -1); 
        for(int i=1; i<=n; i++){
            printf("%d\n", max(dp[0][i], dp[2][i]));
        }
    }
    return 0;
}

2、用树的直径求解：3次dfs()。前两次求树的直径，后两次求得所有点距离直径端点的最远距离。

/*
 * 树中的最长路径， 
*/ 
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4+10;
struct edge{
    int to, val;
    edge(int a, int b) : to(a), val(b) {}
};
vector<edge> G[maxn];
int dp[maxn], max_len, s;

void dfs(int x, int f, int len){
//len:起点到当前点的距离
    if(max_len <= len){
        s = x;
        max_len = len;
    }
    for(int i=0; i<G[x].size(); i++){
        int to = G[x][i].to, w = G[x][i].val;
        if(f == to) continue;
        dfs(to, x, len+w);
        dp[to] = max(dp[to], len+w);
        //更新起点到当前点的距离 
    }
}
int main(){
    freopen("in.txt", "r", stdin);
    int n;
    while(scanf("%d", &n) != EOF){
        memset(dp, 0, sizeof(dp));
        for(int i=1;i<=n;i++) G[i].clear();
        for(int i=2; i<=n; i++){
            int a,b; scanf("%d%d",&a, &b);
            G[i].push_back(edge(a, b));
            G[a].push_back(edge(i, b));
        }
        s=0, max_len=0;
        dfs(1, -1, 0);
        dfs(s, -1, 0);
        dfs(s, -1, 0);
        for(int i=1; i<=n; i++){
            printf("%d\n", dp[i]);
        }
    }
    return 0;
}
一扁舟
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无向图欧拉路径问题
Lucas_FC_的博客
08-15 1171
无向图的欧拉路径
POJ 1192 最优连通子集 最详细的题解 （无向树树形DP）
K键盘里的青春K
02-19 1721
最优连通子集 Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 2787   Accepted: 1488 Description 众所周知，我们可以通过直角坐标系把平面上的任何一个点P用一个有序数对(x, y)来唯一表示，如果x, y都是整数，我们就把点P称为整
有关无向图的问题
Samaritan123的博客
04-21 438
CF 962F  点击打开链接求一个无向图中所有的出现且仅出现在一个环中的边。 先求出双联通分量，一个双联通分量从直观上来看就是若干个圈并在一起，而且圈与圈之间是通过边来相交的。自己画图感受一下，显然若一个双联通分量就是一个简单环（也就是说点数等于边数），那么该双联通分量的边全是符合要求的，否则这些边就全部不符合要求。#include &lt;vector&gt; #include &lt;cst...
中石油5157: Treasure Map（无向图dp）
雪的期许
04-29 425
5157: Treasure Map时间限制: 1 Sec  内存限制: 128 MB提交: 111  解决: 21[提交][状态][讨论版][命题人:admin]题目描述You have found a treasure map! The map leads you to several gold mines. The mines each produce gold each day, but ...
CodeForces - 1220E Tourism 无向图缩点+树形dp
还我笑颜
09-26 503
题目链接：https://vjudge.net/problem/CodeForces-1220E 题意：n个点m条边的无向连通图，起点s，每个点有权值，求遍历无向图得到的最大权值和。但是不能走回头路，即如果从U走到V那么下一步不可以从V走到U 题解：先缩点再跑个树形dp就可以了，无向图缩点还是第一次写，栈内记录的是边，是通过割边来处理的环，转化成一个树之后，如果他的孩子节点是由环缩成的，那这个...
树形dp问题总结（转发）
12-14
本文将围绕“树形DP问题总结”展开，以“二叉苹果树（ural 1108）”为例，探讨树形DP的思路和应用。 在“二叉苹果树”问题中，我们需要找到一棵二叉树上，保留最多苹果的M个分支。首先，我们定义状态转移方程。对于...
DP状态设计与方程总结
01-31
背包问题是一系列经典的DP问题，涉及在有限容量下选择物品以达到某种目标，如价值最大化或重量最小化。 - **0-1背包** - **背景**：每件物品不可分割，只能选择要么携带要么放弃。 - **状态设计**：`dp[i][j]`...
DP:动态编程！
03-21
- 非常规DP：如树形DP、图DP等，适用于非线性结构的问题。 3. **DP的常见问题类型：** - 背包问题：0/1背包、完全背包、多重背包等。 - 最长子序列问题：最长公共子序列、最长递增子序列等。 - 计数问题：如...
基环树11111111111
最新发布
07-10
基环树的概念源于无向图，它包含了一个环（循环），环上的每个节点同时也是各自独立树的根节点。基环树有多种描述方式： 1. **n个点n条无向边的连通图**，意味着每对节点之间恰好有一条边相连。 2. **n个点n条无向...
代码库图书参考.pdf
12-01
- **无向图找桥**：桥是无向图中删去后会导致图不连通的边，可以使用Tarjan算法或Kosaraju算法来查找。 - **无向图连通度（割）**：计算无向图的连通分支，了解图的分块结构，常用DFS或BFS实现。 - **最大团问题*...
【NOIP2017提高A组模拟9.7】简单无向图 dp
Marcus
09-16 425
题目题目大意现在有一些度数为1，一些度数为2的点，求它们构成图的不同的方案数tj设有t1个度数为1的点，t2个度数为2的点，容易发现，答案只与t1,t2的数量有关，那么我们不妨设f[t1][t2]表示现在已经做了t1个1号点,t2个2号点的方案数 转移比较神奇，觉得出题人好** 分为下面的4种情况 1：当t2为0时我们新增若干条长度为2的链，我们将不会在这些链中间加其他任何点 2：新增形如1
JZOJ5351. 【NOIP2017提高A组模拟9.7】简单无向图 DP+组合数学
老臣
09-08 576
题意：给出n个点和每个点的度数，问能有多少种组合方式形成一个简单无向图（多个联通块允许）。n<=2e3.这题充分暴露出我的组合数学有多差。。 首先你需要手玩一段时间发现构造的图要不然是链要不然是环。 然后我们就可以按照情况DP了。 首先对于所有di=1的点，我肯定只能连成一条链。 那很好办了，设f[i][j]f[i][j]表示有i个度数为2的点，j个用来构造环，i-j个用来构造链的情况。
无向图最短路径问题
热门推荐
jphaoren的专栏
03-29 1万+
转自：http://giszpp.spaces.live.com/blog/cns!4593EEA7FACB3D7F!435.entry问题描述：在一个无向图中，有若干个点。某些点存在路径。如何从一个点到达另一个点使走的路程最短？    它是运用贪心的算法不断添加点从而到达终点。建立一个集合，在代码中可以用来标记一下就可以。这个集合的初始时只有起点，我们把从源到u且中间只经过S中顶点的路程为从源到u的特殊路径，并用dist数组记录当前每个顶点所对应的最短特殊路径。Dijkstra算法从源出发，达到直接相连的
【练习】判断无向图是否是树
time-space的博客
01-16 1万+
一个无向图G是一棵树的条件是G必须是无回路的连通图或是有n-1条边的连通图，这里采用后者实现。   在深度搜索遍历的过程中，同时对遍历过的顶点和边数计数，当全部顶点都遍历过且边数为2∗(n−1)2*(n-1)时，这个图就是一棵树，否则不是一棵树。 #include #include #include #include /*图的邻接表类型定义*/ typedef char VertexTyp
判断无向图是否是一颗树
1周是1年的2%
09-28 1392
思路： 无向图是树的条件是有n-1条边的连通图 int visit[MAXV]; void DFS2(AdjGraph *G, int v, int &vn, int &en){ visit[v] = 1; vn++; ArcNode *p = G->adjlist[v].firstarc; while(p != NULL){ en++;//注意此句写...
2015软专算法题T1（无向图树）
UncleJokerly
11-19 199
请按照如下要求设计一个算法：将整型一维数组A[n]调整为左右两个部分，使得左边所有元素均为奇数。右边所有元素均为偶数，要求算法时间复杂度为O(n)，空间复杂度为O(1)。
2020 CCPC-Wannafly Winter Camp Day3 C 无向图定向 （状压DP）
邵光亮的博客
02-23 560
题目描述 火山哥手里有一个 n{n}n 个点 m{m}m 条边的无向图。 现在，火山哥请你把无向图的每条边确定一个方向，使之成为一个 DAGDAGDAG，并且最小化最长路的长度。 这里一条路径的长度指的是经过边的数量。 输入描述: 第一行两个整数 n,mn,mn,m，分别表示图的点数和边数。 接下来 mmm 行，每行两个正整数 u,vu,vu,v，表示一条无向图。 输入数据保证无重边无自环，点编号...
有向图或者无向图概率dp
魔笛手的博客
04-18 1069
概要：一般形成环的用高斯消元法求解。但是递推公式只和少数变量相关，可以考虑分离出系数。总结：（看完下面的例题再来看这部分）1.这类题型一般可以先写出原始公式然后分离出困难的变量，比如第二题的dp[1]dp[1] , dp[father[i]]dp[father[i]] , 都是很难处理的变量，就可以把它们作为待定系数的变量 2.将剩下的变量通过待定系数的公式带入消去,比如例题2,∑dp[child
(简单的)-＞介绍 树形DP介绍
lakafl的博客
10-04 77
数形DP 概念 给定一棵有N个节点的树(通常是无根树，也就是有N-1条无向边)，我们可以任选一个节点为根节点，从而定义出每个节点的深度和每棵子树的根。 在树上设计动态规划算法时，一般就以节点从深到浅(子树从小到大)的顺序作为DP的“阶段”。DP的状态表示中，第一维通常是节点编号(代表以该节点为根的子树)。大多数时候，我们采用递归的方式实现树形动态规划。对于每个节点x，先递归在它的每个子节点上进行DP，在回溯时，从子节点向节点x进行状态转移。 用途 最大独立子集 最大独立子集的定义是，对于一个树
树型背包优化：动态规划在树结构中的应用
树的定义包括几个关键特征：n个节点和n-1条边构成的无向图，每个节点可能有多个后继但只有一个前驱，且无环存在。这种结构允许通过递归定义来处理问题，使得树型动规能够解决更复杂的问题，如找出以某个节点为根的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值