《剑指 Offer》专项突破版 - 面试题 101、102、103 和 104 : 和动态规划相关的背包问题（C++ 实现）

最新推荐文章于 2024-06-12 18:28:23 发布
最新推荐文章于 2024-06-12 18:28:23 发布
阅读量601 收藏 24
点赞数 20
分类专栏： 数据结构 文章标签： 动态规划 c++ 算法 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/melonyzzZ/article/details/137324527
版权

目录

前言

面试题 101 : 分割等和子集

面试题 102 : 加减的目标值

面试题 103 : 最少的硬币数目

方法一

方法二

面试题 104 : 排列的数目

 

前言

背包问题是一类经典的可以应用动态规划来解决的问题。背包问题的基本描述如下：给定一组物品，每种物品都有其重量和价格，在限定的总重量内如何选择才能使物品的总价格最高。由于问题是关于如何选择最合适的物品放置于给定的背包中，因此这类问题通常被称为背包问题。

根据物品的特点，背包问题还可以进一步细分。如果每种物品只有一个，可以选择将之放入或不放入背包中，那么可以将这类问题称为 0-1 背包问题。0-1 背包问题是最基本的背包问题，其他背包问题通常可以转化为 0-1 背包问题。

如果第 i 种物品最多有 M_i 个，也就是每种物品的数量有限，那么这类背包问题称为有界背包问题（也可以称为多重背包问题）。如果每种物品的数量都是无限的，那么这类背包问题称为无界背包问题（也可以称为完全背包问题）。

下面通过几个典型的题目来分析如何根据题目的特点确定背包问题的类型并加以解决。

面试题 101 : 分割等和子集

题目：

给定一个非空的正整数数组，请判断能否将这些数字分成和相等的两部分。例如，如果输入数组为 [3, 4, 1]，将这些数字分成 [3, 1] 和 [4] 两部分，它们的和相等，因此输出 true；如果输入数组为 [1, 2, 3, 5]，则不能将这些数字分成和相等的两部分，因此输出 false。

分析：

如果能够将数组中的数字分成和相等的两部分，那么数组中所有数字的和（记为 sum）应该是一个偶数。也可以换一个角度来描述这个问题：能否从数组中选出若干数字，使它们的和等于 sum / 2（将 sum / 2 记为 target）？

如果将数组中的每个数字看成物品的重量，也可以这样描述这个问题：能否选择若干物品，使它们刚好放满一个容量为 target 的背包？由于每个物品（数字）最多只能选择一次，因此这是一个 0-1 背包问题。

传统的 0-1 背包问题要求选择的物品的重量之和不能超过背包的总容量，而这道题则要求选择的物品的重量之和等于背包的总容量。

如果有 n 个物品，每步判断一个物品是否要放入背包，也就是说解决这个问题需要 n 步，并且每步都面临放入或不放入两个选择，这看起来是一个能用回溯法解决的问题。但这个题目没有要求列出所有可能的放满背包的方法，而是只要求判断是否存在放满背包的方法，也就是判断方法的数量是否大于 0。因此，这个问题更适合用动态规划解决。

分析确定状态转移方程：

应用动态规划的关键在于确定状态转移方程。可以用函数 f(i, j) 表示能否从标号为 0 的物品到标号为 i（0 <= i < n）的物品中选择若干物品放满容量为 j（0 <= j <= target）的背包。如果总共有 n 个物品，背包容量为 target，那么 f(n - 1, target) 就是问题的解。

当判断能否从标号为 0 的物品到标号为 i 的物品中选择若干物品放满容量为 j 的背包时，对标号为 i 的物品有两个选择。

  1. 不将标号为 i 的物品放入背包中，如果能从标号为 0的物品到标号为 i - 1 的物品中选择若干物品放满容量为 j 的背包（即 f(i - 1, j) 为 true），那么 f(i, j) 也为 true。

    前提：i > 0。

  2. 将标号为 i 的物品放入背包中，如果能从标号为 0 的物品到标号为 i - 1 的物品中选择若干物品放满容量为 j - nums[i] 的背包（即 f(i - 1, j - nums[i]) 为 true），那么 f(i, j) 就为 true。

    前提：i > 0 && j >= nums[i]。

当 i 等于 0 时，f(0, 0) 为 true；f(0, nums[0]) 为 true；f(0, j) = false，j != 0, nums[0]。\begin{cases} f(0, 0) = f(0, nums[0]) = true \\ f(0, j) = false, j \neq 0, nums[0] \\ f(i, j) = f(i - 1, j), i > 0 \ \&\& \ j < nums[i] \\ f(i, j) = f(i - 1, j) \ || \ f(i - 1, j - nums[i]), i > 0 \ \&\& \ j \ge nums[i] \end{cases}

判断能否将数组 [3, 4, 1] 分成和相等的两部分的过程：

i \ j01234
0truefalsefalsetruefalse
1truefalsefalsetruetrue
2truetruefalsetruetrue
class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for (int num : nums)
        {
            sum += num;
        }
        if (sum % 2)
            return false;
        
        int n = nums.size();
        int target = sum / 2;
        vector<vector<bool>> dp(n, vector<bool>(target + 1, false));
        dp[0][0] = true;
        if (nums[0] > target)
            return false;
        else
            dp[0][nums[0]] = true;
        
        for (int i = 1; i < n; ++i)
        {
            for (int j = 0; j <= target; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if (!dp[i][j] && j >= nums[i])
                    dp[i][j] = dp[i - 1][j - nums[i]];
            }
        }
        return dp[n - 1][target];
    }
};

上述代码的时间复杂度和空间复杂度都是 O(n * target)。

优化空间效率：

可以优化空间效率。需要注意的是，上述代码在计算 f(i, j) 时，只需要用到行号为 i - 1 的值，因此保存表格中的两行就可以。可以创建一个只有两行的数组 dp，f(i, j) 保存在 dp[i % 2][j] 中。

还可以进一步优化空间效率。如果 f(i, j) 和 f(i - 1, j) 可以保存到数组的同一个位置，那么只需要一个一维数组。

  1. 如果按照从左到右的顺序填充表格，f(i - 1, j) 在计算完 f(i, j) 之后还可能在计算右边其他值时被用到，那么不能直接用 f(i, j) 替换 f(i - 1, j)。

  2. 但是如果按照从右到左的顺序填充表格，f(i - 1, j) 在计算完 f(i, j) 之后就再也用不到，f(i - 1, j) 被 f(i, j) 直接替换掉不会引起任何问题。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for (int num : nums)
        {
            sum += num;
        }
        if (sum % 2)
            return false;
        
        int n = nums.size();
        int target = sum / 2;
        vector<bool> dp(target + 1, false);
        dp[0] = true;
        if (nums[0] > target)
            return false;
        else
            dp[nums[0]] = true;
        
        for (int i = 1; i < n; ++i)
        {
            for (int j = target; j >= nums[i]; --j)
            {
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
        return dp[target];
    }
};

优化之后的代码的时间复杂度仍然是 O(n * target)，空间复杂度则变成了 O(target)。

面试题 102 : 加减的目标值

题目：

给定一个非空的正整数数组和一个目标值 target，如果为每个数字添加 "+" 或 "-" 运算符，请计算有多少种方法可以使这些整数的计算结果为 target。例如，如果输入数组 [2, 2, 2] 并且 target 等于 2，有 3 种添加 "+" 或 "-" 的方法使结果为 2，它们分别是 2 + 2 - 2 = 2、2 - 2 + 2 = 2 及 -2 + 2 + 2 = 2。

分析：

在分析解决这个问题之前，需要先做数学运算。为输入的数组中的有些数字添加 "+"，有些数字添加 "-"。如果所有添加 "+" 的数字之和为 p，所有添加 "-" 的数字之和为 q，按照题目的要求 p - q = target ①。 将数组中所有数字之和记为 sum，则 p + q = sum ②。将 ① 和 ② 等式的左右两边分别相加，就可以得到 2p = target + sum，即 p = (target + sum) / 2 ③。

等式 ③ 表明，如果能够找出数组中和为 (target + sum) / 2 的数字，并给它们添加 "+"，然后给其他数字添加 "-"，那么最终的计算结果就是 target。因此，这个题目等价于计算从数组中选出和为 (target + sum) / 2 的数字的方法的数目。这和面试题 101 非常类似，是一个典型的 0-1 背包问题，可以用动态规划解决。

分析确定状态转移方程：

用动态规划解决问题的关键在于确定状态转移方程。可以用函数 f(i, j) 表示在数组的前 i + 1 个数字（即 nums[0···i]，0 <= i < n）中选出若干数字使和等于 j（0 <= j <= p）的方法的数目。如果数组的长度为 n，目标值为 p，那么 f(n - 1, p) 就是整个问题的解。

这个问题的状态转移方程和面试题 101 的非常类似，区别在于这里的 f(i, j) 的值不再只是一个 true 或 false 的标识，而是一个数值。\begin{cases} f(0, 0) = f(0, nums[0]) = 1, nums[0] \neq 0 \\ f(0, 0) = f(0, nums[0]) = 2, nums[0] = = 0 \\ f(0, j) = 0, j \neq 0, nums[0] \\ f(i, j) = f(i - 1, j), i > 0 \ \&\& \ j < nums[i] \\ f(i, j) = f(i - 1, j) + f(i - 1, j - nums[i]), i > 0 \ \&\& \ j >= nums[i] \end{cases}

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int num : nums)
        {
            sum += num;
        }
        if ((target + sum) % 2 || sum < target)
            return 0;
        
        int p = (target + sum) / 2;
        vector<int> dp(p + 1, 0);
        dp[0] = 1;
        if (nums[0] <= p)
            dp[nums[0]] = 1;
        
        if (nums[0] == 0)
            dp[0] = 2;
        
        for (int i = 1; i < nums.size(); ++i)
        {
            for (int j = p; j >= nums[i]; --j)
            {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[p];
    }
};

上述代码的时间复杂度是 O(n * p)，空间复杂度是 O(p)。

面试题 103 : 最少的硬币数目

题目：

给定正整数数组 coins 表示硬币的面额和一个目标总额 amount，请计算凑出总额 amount 至少需要的硬币数目。每种硬币可以使用任意多枚。如果不能用输入的硬币凑出给定的总额，则返回 -1。例如，如果硬币的面额为 [1, 3, 9, 10]，总额 amount 为 15，那么至少需要 3 枚硬币，即 2 枚面额为 3 的硬币及 1 枚面额为 9 的硬币。

分析：

如果将每种面额的硬币看成一种物品，而将目标总额看成背包的容量，那么这个问题等价于求背包放满时物品的最少件数。值得注意的是，这里每种面额的硬币可以使用任意多次，因此这个问题不再是 0-1 背包问题，而是一个无界背包问题（也叫完全背包问题）。

方法一

分析和解决完全背包问题的思路与 0-1 背包问题的思路类似。用函数 f(i, j) 表示用前 i + 1 种硬币（coins[0···i]，0 <= i < n）凑出总额为 j（0 <= j <= amount）需要的硬币的最少数目。

当使用 0 枚标号为 i 的硬币时，f(i, j) 等于 f(i - 1, j)（用前 i - 1 种硬币凑出总额为 j 需要的最少硬币数目，再加上 0 枚标号为 i 的硬币）；当使用 1 枚标号为 i 的硬币时，f(i, j) 等于 f(i - 1, j - coins[i]) 加 1（用前 i - 1 种硬币凑出总额为 j - coins[i] 需要的最少硬币数目，再加上 1 枚标号为 i 的硬币）；以此类推，当使用 k 枚标号为 i 的硬币时，f(i, j) 等于 f(i - 1, j - k * coins[i]) 加 k（用前 i - 1 种硬币凑出总额 j - k * coins[i] 需要的最少硬币数目，再加上 k 枚标号为 i 的硬币）。由于目标是求出硬币数目的最小值，因此 f(i, j) 是上述所有情况的最小值。\begin{cases} f(0, k * coins[0]) = k, k \ge 0 \ \&\& \ k * coins[0] \le amount \\ f(0, j) = amount + 1, j \neq k * coins[0] \\ f(i, j) = min(f(i - 1, j - k * coins[i]) + k), i > 0 \ \&\& \ k * coins[i] \le j \end{cases}

每种硬币的面额一定大于或等于 1，如果能用硬币凑出总额 amount，那么需要的硬币数目一定小于或等于 amount。因此，可以用 amount + 1 表示某个面额不能用输入的硬币凑出。

如果硬币有 n 种，目标总额为 amount，那么 f(n - 1, amount) 就是问题的解。

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, amount + 1);
        for (int k = 0; k * coins[0] <= amount; ++k)
        {
            dp[k * coins[0]] = k;
        }
​
        for (int i = 1; i < coins.size(); ++i)
        {
            for (int j = amount; j >= 0; --j)
            {
                for (int k = 1; k * coins[i] <= j; ++k)
                {
                    dp[j] = min(dp[j], dp[j - k * coins[i]] + k);
                }
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }
};

上述代码的时间复杂度是 O(n * amount * k)，空间复杂度是 O(amount)。

方法二

还可以换一种角度分析这个问题。用函数 f(i) 表示凑出总额为 i 的硬币需要的最少数目。需要注意的是，这个函数只有一个参数，表示硬币的总额。如果目标总额为 amount，那么 f(amount) 就是整个问题的解。

为了凑出总额为 i 的硬币，有如下选择：在总额为 i - coins[0] 的硬币中添加 1 枚标号为 0 的硬币，此时 f(i) 等于 f(i - coins[0]) + 1（在凑出总额为 i - coins[0] 的最少硬币数的基础上加上 1 枚标号为 0 的硬币）；在总额为 i - coins[1] 的硬币中添加 1 枚标号为 1 的硬币，此时 f(i) 等于 f(i - coins[1]) + 1。以此类推，在总额为 i - coins[n - 1] 的硬币中添加 1 枚标号为 n - 1 的硬币，此时 f(i) 等于 f(i - coins[n - 1])。因为目标是计算凑出总额为 i 的硬币，所以 f(i) 是上述所有情况的最小值。

f(i) = min(f(i - coins[j]) + 1), coins[j] \le i

显然，f(0) 等于 0，即凑出总额为 0 至少需要 0 枚硬币。

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, amount + 1);
        dp[0] = 0;
​
        for (int i = 1; i <= amount; ++i)
        {
            for (int j = 0; j < coins.size(); ++j)
            {
                if (coins[j] <= i)
                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }
};

上述代码的时间复杂度是 O(n * amount)，空间复杂度是 O(amount)。

面试题 104 : 排列的数目

题目：

给定一个非空的正整数数组 nums 和一个目标值 target，数组中的所有数字都是唯一的，请计算数字之和等于 target 的所有排列的数目。数组中的数字可以在排列中出现任意次。例如，输入数组 [1, 2, 3]，目标值 target 为 3，那么总共有 4 个排列的数字之和等于 3，它们分别是 { 1, 1, 1 }、{ 1, 2 }、{ 2, 1 } 及 { 3 }。

分析：

如果将数组中的每个数字看成硬币的面额，而将目标值 target 看成总额，那么这个问题和面试题 103 是非常类似的。可以用类似的思路来推导状态转移方程。

用 f(i) 表示数字之和等于 i 的所有排列的数目。

为了得到数字之和等于 i 的所有排列，有如下选择：在数字之和等于 i - nums[0] 的排列中添加标号为 0 的数字，此时 f(i) 等于 f(i - nums[0])；在数字之和等于 i - nums[1] 的排列中添加标号为 1 的数字，此时 f(i) 等于 f(i - nums[1])；以此类推，在数字之和等于 i - nums[n - 1] 的排列中添加标号为 n - 1 的数字（n 为数组的长度），此时 f(i) 等于 f(i - nums[n - 1])。因为目标是求出所有数字之和等于 i 的排列的数目，所以将上述情况全部累加起来。f(i) = \sum f(i - nums[j]), i \ge nums[j]

由于只有一个空排列的数字之和等于 0，因此 f(0) 等于 1。

i0123
f(i)1124
数字之和等于 i 的所有排列{ }{ 1 }{ 1, 1 }、{ 2 }{ 1, 1, 1 }、{ 2, 1 }、{ 1, 2 }、{ 3 }
class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<unsigned int> dp(target + 1);
        dp[0] = 1;
​
        for (int i = 1; i <= target; ++i)
        {
            for (int j = 0; j < nums.size(); ++j)
            {
                if (i >= nums[j])
                    dp[i] += dp[i - nums[j]];
            }
        }
        return dp[target];
    }
};

上述代码的时间复杂度是 O(n * target)，空间复杂度是 O(target)。

melonyzzZ
关注
  • 20
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
“动态规划” 面试高频题——剑指offer精选万字总结
米莱虾
03-06 2186
❥分享初学DP时的两篇文章，希望对大家有所帮助❥ 算法设计与分析之 “动态规划” 经典习题总结&AC代码_夏旭的博客-CSDN博客 动态规划之4大背包问题详解_夏旭的博客-CSDN博客 首先我们大致了解一下动态规划 (dynamic programming) 的定义和核心套路： 动态规划 (DP) 是一种算法技术，它将大问题分解为更简单的子问题，对整体问题的最优解决方案取决于子问题的最优解决方案。 某些问题往往有 2个特征：重叠子问题、最优子结构。而用动规可以高效率地处理具有这...
剑指Offer（专项突破版）数据结构与算法名企面试题精讲1
08-03
前言2021年1月22日，我从工作超过10年的微软离职，并将于25日入职一家相对而言规模要小很多的初创公司，开始一段新的职业旅程。与所有程序员一样，换公司工作我
《剑指 Offer》专项突破版 - 面试题 88 : 动态规划的基础知识（C++ 实现）
melonyzzZ的博客
03-20 1072
面试题 88 : 爬楼梯的最少成本（C++ 实现）
LeetCode 剑指 Offer II 动态规划（四） 专题总结
热门推荐
一只小逸白
03-06 1万+
往期文章 ： LeetCode 剑指 Offer II 回溯(上) 专题总结 LeetCode 剑指 Offer II 回溯(下) 专题总结 LeetCode 剑指 Offer II 动态规划（一） 专题总结 LeetCode 剑指 Offer II 动态规划（二） 专题总结 LeetCode 剑指 Offer II 动态规划（三） 专题总结 目录100. 三角形中最小路径之和101. 分割等和子集102. 加减的目标值 后两道都是0-1背包问题 100. 三角形中最小路径之和 题目： 给定一个三角形
在线编程——动态规划常见的面试问题总结（Python）
GeekZW的博客
08-29 8602
在线编程——动态规划常见的面试问题总结（Python） O、求解方法：阶段 + 状态变量 + 状态转移方程 + 边界条件 （1）划分阶段：按照问题的时间或空间特征，把问题分为若干个阶段。在划分阶段时，注意划分后的阶段一定要是有序的或者是可排序的，否则问题就无法求解。 （2）确定状态和状态变量：将问题发展到各个阶段时所处于的各种...
《剑指offer》75题 C++详细题解
MuqiuWhite的博客
12-06 3132
刷题快乐~
【C++】【学习笔记】【动态规划问题详解与例题】记忆化搜索与暴力穷举思想 ；0-1 背包问题；子序列问题；
多丰富下自己呀
07-05 435
目录总框架总目录：九、动态规划问题1、参考练习题2、记忆化搜索与暴力穷举思想的重要性3、0-1 背包问题4、0-1 背包问题- 变种5、0-1 背包问题- 例题6、 最长上升子序列7、 最长上升子序列 -例题7、 最长公共子序列 LCS8、 动态规划找出具体解1、子序列具体解2、0 - 1 背包问题具体解参考 总框架 总目录： 【学习笔记】玩转算法面试-- Leetcode真题分门别类讲解 九、动态规划问题 经典动态规划问题：斐波那契数列； 记忆化搜索：递归的基础上，添加记忆化；自上而下解决问题。 动态
动态规划常见面试编程题(python)
ys_1991的博客
03-13 1906
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;在线编程——动态规划常见的面试问题总结（Python） &nbsp; O、求解方法：阶段 + 状态变量 + 状态转移方程 + 边界条件 （1）划分...
算法设计方法4：动态规划经典例题总结
何哥的博客
03-05 4407
前言：各大公司关于动态规划的笔试题太多了，必须得掌握。上篇文章提过，使用动态规划的五大步骤： 1. 判题题意是否为找出一个问题的最优解 2. 将原问题分解为子问题 3. 从下往上分析问题 ，找出这些问题之间的关联（状态转移方程），如何从一个或多个已知状态求出另一个未知状态的值。（递推型） 4. 讨论底层的边界问题，确定一些初始状态（边界状态）的值，并用数组存储初始子问题的解 5. 解决问题（通...
【数据结构与算法】《剑指offer》学习笔记----第一章、第二章 基础知识（含1-15题）
qq_30885821的博客
06-13 1278
学习概要 数据结构 数组 字符串 链表（高频） 树（尤其二叉树） 栈（与递归调用密切相关） 队列（图包括树的层序遍历中用到） 算法 查找（二分查找） 排序（快速排序、归并排序） 回溯法（解决迷宫类似问题） 动态规划（求最优解） 贪婪算法（动态规划过程中每一步都存在一个可能的最优解的选择时可以尝试贪婪算法） 循环和递归的不同实现 位运算 正文开始： 1 编程语言 1 sizeof 定义一个空类型（不包含任何成员变量和成员函数）—> sizeof值为1，而非0，因为我们生命该类型的实例的时候必须在内存中占
《剑指Offer-名企面试官精讲典型编程题》第2版 C++实现.zip
01-20
C++面试题库，大厂进阶之路； 一份涵盖大部分 C++ c程序员所需要掌握的核心知识；涉及C++面试常问题、设计模式、数据结构、操作系统及网络等
剑指offer面试题1-10
01-20
剑指offer 面试题1：赋值运算符函数、 为如下CMyString类型添加赋值运算符函数 #include #include //为下列函数添加赋值运算符函数 class CMyString { public: CMyString(char *pData = nullptr); CMyString(const...
《剑指Offer》刷题笔记——面试题57. 和为s的两个数字
12-22
1、剑指解析 2、代码实现 class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: if len(nums)target or nums[j]+nums[j-1]<target: return [] while i<j: if nums[i]+nums[j]...
Python《剑指offer》算法实现-正方体对面和相同
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 981
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 134
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 661
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1094
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
剑指offer c++
07-27
- *1* *2* [剑指offer第二版(C++实现)](https://blog.csdn.net/qq_40618919/article/details/125178645)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值