【力扣】组合总和系列

最新推荐文章于 2023-11-28 19:57:34 发布
最新推荐文章于 2023-11-28 19:57:34 发布
阅读量252 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/118343443
版权

【力扣】组合总和系列

Leetcode 0039 组合总和

题目描述：Leetcode 0039 组合总和

在这里插入图片描述

分析

  • 本题的考点：递归回溯。

  • 直接暴搜即可。

代码

  • C++
class Solution {
public:
    vector<vector<int>> ans;

    vector<vector<int>> combinationSum(vector<int>& c, int target) {

        vector<int> path;
        dfs(c, target, 0, path);
        return ans;
    }

    void dfs(vector<int> &c, int target, int u, vector<int> path) {
		// 每次递归path都会新创建一个，因此最后不用恢复现场
        if (target == 0) {
            ans.push_back(path);
            return;
        }
        if (u == c.size()) return;

        for (int i = 0; c[u] * i <= target; i++) {
            dfs(c, target - c[u] * i, u + 1, path);
            path.push_back(c[u]);
        }
    }
};

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;  // 区别，这种写法的效率远远高于上一种

    vector<vector<int>> combinationSum(vector<int>& c, int target) {

        dfs(c, target, 0);
        return ans;
    }

    void dfs(vector<int> &c, int target, int u) {
		// 每次递归path用的是同一个，因此需要恢复现场
        if (target == 0) {
            ans.push_back(path);
            return;
        }
        if (u == c.size()) return;

        for (int i = 0; c[u] * i <= target; i++) {  // 枚举放入c[u]的个数
            dfs(c, target - c[u] * i, u + 1);
            path.push_back(c[u]);
        }

        for (int i = 0; c[u] * i <= target; i++) path.pop_back();  // 区别，恢复现场
    }
};
  • Java
class Solution {

    List<List<Integer>> ans = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] c, int target) {

        LinkedList<Integer> path = new LinkedList<>();
        dfs(c, target, 0, path);
        return ans;
    }

    // 当前考察到c[u], 当前方案存储在path中
    private void dfs(int[] c, int target, int u, LinkedList<Integer> path) {
		// 每次递归path用的是同一个，因此需要恢复现场
        if (target == 0) {
            ans.add((List<Integer>) path.clone());
            return;
        }
        if (u == c.length) return;

        for (int i = 0; c[u] * i <= target; i++) {  // 枚举放入c[u]的个数
            dfs(c, target - c[u] * i, u + 1, path);
            path.add(c[u]);
        }
        for (int i = 0; c[u] * i <= target; i++) path.removeLast();  // 恢复现场
    }
}
  • Python
class Solution:
    def combinationSum(self, c: List[int], target: int) -> List[List[int]]:
        ans = []
        path = []
        self.dfs(c, target, 0, path, ans)
        return ans

    def dfs(self, c, target, u, path, ans):
        if target == 0:
            ans.append(path.copy())
            return
        if u == len(c):
            return

        i = 0
        while c[u] * i <= target:
            self.dfs(c, target - c[u] * i, u + 1, path, ans)
            path.append(c[u])
            i += 1

        i = 0
        while c[u] * i <= target:
            path.pop(len(path) - 1)
            i += 1

时空复杂度分析

  • 时间复杂度：指数级别。

  • 空间复杂度：和递归深度有关。

Leetcode 0040 组合总和II

题目描述：Leetcode 0040 组合总和II

在这里插入图片描述

分析

  • 本题的考点：递归回溯。

  • 不同于Leetcode 0039 组合总和，这一题candidates中可以有重复元素，并且candidates中的每个元素只能使用一次。

  • 首先我们要对数组进行排序，这样方便我们统计每个数据出现的次数，比如某个数据出现2次，则最多选取这个数据2次。

  • 类似于Leetcode 0039 组合总和的做法，直接暴搜即可，不过在循环某个数据可以放入几个时需要在循环中加入限制条件。

代码

  • C++
class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;

    vector<vector<int>> combinationSum2(vector<int>& c, int target) {

        sort(c.begin(), c.end());  // 方便后面统计数据出现次数

        dfs(c, target, 0);
        return ans;
    }

    void dfs(vector<int> &c, int target, int u) {

        if (target == 0) {
            ans.push_back(path);
            return;
        }
        if (u == c.size()) return;

        // 统计c[u]出现次数
        int k = u + 1;
        while (k < c.size() && c[k] == c[u]) k++;
        int cnt = k - u;

        for (int i = 0; c[u] * i <= target && i <= cnt; i++) {
            dfs(c, target - c[u] * i, k);
            path.push_back(c[u]);
        }

        for (int i = 0; c[u] * i <= target && i <= cnt; i++) path.pop_back();
    }
};
  • Java
class Solution {

    List<List<Integer>> ans = new ArrayList<>();

    public List<List<Integer>> combinationSum2(int[] c, int target) {

        Arrays.sort(c);

        LinkedList<Integer> path = new LinkedList<>();
        dfs(c, target, 0, path);
        return ans;
    }

    // 当前考察到c[u], 当前方案存储在path中
    private void dfs(int[] c, int target, int u, LinkedList<Integer> path) {
		// 每次递归path用的是同一个，因此需要恢复现场
        if (target == 0) {
            ans.add((List<Integer>) path.clone());
            return;
        }
        if (u == c.length) return;

        int k = u + 1;
        while (k < c.length && c[k] == c[u]) k++;
        int cnt = k - u;

        for (int i = 0; c[u] * i <= target && i <= cnt; i++) {  // 枚举放入c[u]的个数
            dfs(c, target - c[u] * i, k, path);
            path.add(c[u]);
        }
        for (int i = 0; c[u] * i <= target && i <= cnt; i++) path.removeLast();  // 恢复现场
    }
}
  • Python
class Solution:
    def combinationSum2(self, c: List[int], target: int) -> List[List[int]]:
        c.sort()

        ans = []
        path = []
        self.dfs(c, target, 0, path, ans)
        return ans

    def dfs(self, c, target, u, path, ans):
        if target == 0:
            ans.append(path.copy())
            return
        if u == len(c):
            return

        k = u + 1
        while k < len(c) and c[k] == c[u]:
            k += 1
        cnt = k - u

        i = 0
        while i <= cnt and c[u] * i <= target:
            self.dfs(c, target - c[u] * i, k, path, ans)
            path.append(c[u])
            i += 1

        i = 0
        while i <= cnt and c[u] * i <= target:
            path.pop(len(path) - 1)
            i += 1

时空复杂度分析

  • 时间复杂度：指数级别。

  • 空间复杂度：和递归深度有关。

Leetcode 0216 组合总和III

题目描述：Leetcode 0216 组合总和III

在这里插入图片描述

分析

  • 本题的考点：递归回溯。

  • 类似于Leetcode 0077 组合，我们可以枚举每个位置放置哪个数据；这里的写法类似于LC77中的Java写法。

  • 注意：当k大于9的话，无解，可以直接返回；或者n大于10-k ~ 9所有数据之和，无解，也可以直接返回。

代码

  • C++
class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;

    vector<vector<int>> combinationSum3(int k, int n) {
        if (k > 9 || n > (19 - k) * k / 2) return ans;

        dfs(1, n, k);
        return ans;
    }

    // 还有u个位置需要放置数据
    void dfs(int start, int n, int k) {
        if (!n) {
            if (!k) ans.push_back(path);
        } else if (k) {
            for (int i = start; i <= 9; i++)
                if (n >= i) {
                    path.push_back(i);
                    dfs(i + 1, n - i, k - 1);
                    path.pop_back();
                }
        }
    }
};
  • Java
class Solution {

    List<List<Integer>> ans = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> combinationSum3(int k, int n) {
        if (k > 9 || n > (19 - k) * k / 2) return ans;

        dfs(1, n, k);
        return ans;
    }
	
    // 还有u个位置需要放置数据
    private void dfs(int start, int n, int k) {
        if (n == 0) {
            if (k == 0) ans.add(new LinkedList<>(path));
        } else if (k != 0) {
            for (int i = start; i <= 9; i++)
                if (n >= i) {
                    path.add(i);
                    dfs(i + 1, n - i, k - 1);
                    path.removeLast();
                }
        }
    }
}

时空复杂度分析

  • 时间复杂度：指数级别。
  • 空间复杂度：和递归深度有关。

Leetcode 0377 组合总和 Ⅳ

题目描述：Leetcode 0377 组合总和 Ⅳ

在这里插入图片描述

分析

  • 本题的考点：动态规划。

  • 这一题和完全背包问题十分类似，关于背包问题可以参考：背包九讲。但是和完全背包不同，不同点有两点：（1）这一题要求所选数据之和正好为target；（2）这一题数据相同但是排列不同的序列认为是不同的结果，例如1, 3和3, 1认为是不同的结果。

  • 本题的分析如下：

在这里插入图片描述

代码

  • C++
class Solution {
public:
    int combinationSum4(vector<int>& nums, int m) {

        int n = nums.size();
        vector<long long> f(m + 1);  // 中间过程int会溢出
        f[0] = 1;  // 什么都不选也是一种方案
        for (int i = 0; i <= m; i++)
            for (int v : nums)
                if (i >= v)
                    f[i] = (f[i] + f[i - v]) % INT_MAX;
        return f[m];
    }
};
  • Java
class Solution {
    public int combinationSum4(int[] nums, int m) {

        int n = nums.length;
        int[] f = new int[m + 1];  // 不需要考虑溢出问题, lc提交能通过
        f[0] = 1;
        for (int i = 0; i <= m; i++)
            for (int v : nums)
                if (i >= v)
                    f[i] += f[i - v];
        return f[m];
    }
}

时空复杂度分析

  • 时间复杂度： O ( n × m ) O(n \times m) O(n×m)，n为数组长度，m为需要组合出的数。

  • 空间复杂度： O ( m ) O(m) O(m)，m为需要组合出的数。

下一题是为了和 Leetcode 0377 组合总和 Ⅳ 对比：

Leetcode 0518 零钱兑换 II

题目描述：Leetcode 0518 零钱兑换 II

在这里插入图片描述

分析

  • 本题的考点：背包问题。

  • 本题将amout简记为m。问题是：给我们一个容量为m的背包，每个物品的体积由coins给出，每个物品可以使用无数次，问恰好装满背包的方案数。

  • 本题就是一个完全背包问题。关于背包问题可以参考：背包问题（背包九讲）。

  • 注意本题和Leetcode 0322 零钱兑换的区别，LC322让求的是体积恰好是m需要用的最少硬币数，本题求得是体积恰好是m的方案数，还有一类最常规的让求最大价值（体积不超过m的最大价值，体积恰好是m的最大价值，体积不小于m的最小耗费）。

  • 另外注意本题和Leetcode 0377 组合总和 Ⅳ，和本题的唯一区别在于，认为1,2和2,1是不同的方案。因此LC377先循环体积，再循环物品，这样对于每个体积，可以根据最后一个放入的数据分为n类，因此可以实现不同顺序是不同方案。完全背包最初的分析（见背包九讲的分析），是每个物品放置几个数据，因此不同顺序认为是相同方案。

代码

  • C++
class Solution {
public:
    int change(int m, vector<int>& coins) {
        vector<int> f(m + 1);
        f[0] = 1;
        for (int v : coins)
            for (int j = v; j <= m; j++)
                f[j] += f[j - v];
        return f[m];
    }
};
  • Java
class Solution {
    public int change(int m, int[] coins) {
        int[] f = new int[m + 1];
        f[0] = 1;
        for (int v : coins)
            for (int j = v; j <= m; j++)
                f[j] += f[j - v];
        return f[m];
    }
}
  • Python
class Solution:
    def change(self, m: int, coins: List[int]) -> int:
        f = [0 for _ in range(m + 1)]
        f[0] = 1
        for v in coins:
            for j in range(v, m + 1):
                f[j] += f[j - v];
        return f[m]

时空复杂度分析

  • 时间复杂度： O ( n × m ) O(n \times m) O(n×m)，n为数组长度，m是题目中的amout。

  • 空间复杂度： O ( n × m ) O(n \times m) O(n×m)。

你好世界wxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode-17-电话号码的字母组合
m0_49293816的博客
10-18 275
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。 > 注意 1 不对应任何字母。 示例: 输入："23" (2: abc 3: def) 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-numb
Python算法题源代码-LeetCode(力扣)-组合总和
最新发布
02-29
39. 组合总和 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ， 并以列表形式返回。你可以按 任意顺序 返回这些组合。 ...
C++STL中vector容器类的简单操作
AC_Gibson的专栏
01-26 1282
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象；简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 vector容器类的基本操作有： （1）头文件：#include （2）创建对象int类型对象ans：vector ans;
所有可能的路径---对何时使用bfs+状态压缩的稍微总结
CppYyds的博客
08-26 147
文章目录题目dfs回溯关于我为什么是伞兵这件事(何时使用bfs+状压) 题目 dfs回溯 没啥可说的，究极简单+标准 class Solution { public: vector<vector<int>> ans; vector<int> stk; void dfs(vector<vector<int>>& graph, int x, int n) { if (x == n) {
LeetCode学习-第二十八天
qq_58054907的博客
02-02 497
第二十八天 我使用的C++，错误的地方请见谅，文章初衷仅用来督促本人学习，如果恰巧能够给你带来帮助，我会十分开心。 文章目录第二十八天一、90. 子集 II 一、90. 子集 II 给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/subsets-ii 著作权归领扣网络所有。商业转载请联系官方
剑指 Offer II 081. 允许重复选择元素的组合---Python
qiaomm的个人博客
08-23 295
剑指 Offer II 081. 允许重复选择元素的组合 题目描述： 给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。 candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。 对于给定的输入，保证和为 target 的唯一组合数少于 150 个。 示例 1： 输入: candidates = [2,3,6,7], target = 7 输出:
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
力扣刷题力扣刷题力扣刷题
力扣
12-22
力扣刷题 88. 合并两个有序数组 给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。 解题思路 直接将数组num2合并到num1中，再用内置排序方法sort将num1输出 sort函数 ...
Python算法题源代码-LeetCode(力扣)-电话号码的字母组合
02-28
力扣热题Python源代码 题目17. 电话号码的字母组合 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何...
力扣剑指offer.pdf
10-09
剑指offer题解 sword指offer为一份IT行业的知识宝典，涵盖了数组、链表、二叉树等基础数据结构和算法的解决方案。以下是对剑指offer题解的详细介绍： 一、数组中重复的数字 剑指Offer 03.数组中重复的数字的解法...
leetCode 39.组合总和 + 回溯算法 + 剪枝 + 图解 + 笔记
呵呵哒!的博客
11-28 1482
它们绿色节点出现的位置并不一样，发现下图排完序之后，若能找到符合的节点，其实是当前同层的前面是没有不符合的节点的。（描述可能有点问题，大家可以对比一下找规律）带你学透回溯算法-组合总和（对应「leetcode」力扣题目：39.组合总和）| 回溯法精讲！_哔哩哔哩_bilibili。就返回（结束本层递归），这里可以做优化，接着往下看！，和本题的区别，本题没有数量要求，且可以。，只是下一层递归结束判断的时候，发现。，并以列表形式返回。对于给定的输入，保证和为。3).单层搜索的逻辑。2).递归的终止条件。
关于C++中vector＜vector＜int＞ ＞的使用
QWQ___qwq的博客
07-30 3650
1、定义 vector<vector<int>> A;//错误的定义方式 vector<vector<int> > A;//正确的定义方式 2、插入元素 若想定义A = [[0,1,2],[3,4]]，有两种方法。 （1）定义vector B分别为[0,1,2]和[3,4]，然后放入vector A。 vector<vector<int> > A; vector<int> B; B.push_back(0); B.pu
leetcode系列--39.组合总和
weixin_41198447的博客
01-14 189
leetcode系列–第39题.组合总和 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为 target 的不同组合数少于 150 个。 输入：candidates = [2,3,6,
力扣算法回溯篇：组合总和
qq_22494201的博客
09-08 135
题解： 回溯三部曲： 1、确定回溯函数参数 2、确定回溯终止条件 当总和等于目标和时，将该数组加入结果集，返回，当总和大于目标和，直接返回 3、确定单层搜索逻辑 依然for循环横向遍历，递归纵向遍历，如下（代码随想录讲解图）： class Solution { public: vector<vector<int>> result; vector<int> path; void backtracking(vector<int>&amp.
力扣：组合总和 (系列，先看此篇)
ZhangyiA的博客
12-07 383
题目描述 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明：所有数字（包括 target）都是正整数 ， 且解集不能包含重复的组合。 来源 力扣：39 组合总和 参考大佬 liweiwei1494 的题解 输入：candidates = [2,3,6,7], target = 7, 所求解集为：[[7],[2,2,3]] 题目分析 以下给出
力扣的组合总和解法 （Python）
chutu2018的博客
03-09 310
力扣的组合总和解法 题目描述： 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 示例 1: 输入: candidates = [2,3,6,7], target =...
39.组合总和 - 力扣
岁寒良木的博客
09-23 141
回溯法的重要思想：通过枚举法，对所有可能性进行遍历。但是枚举的顺序是 一条路走到黑，发现走到黑之后，退一步，再向前尝试没走过的路。直到所有路都试过。因此回溯法可以简单的理解为：走不通就退一步的方枚举法就叫回溯法。
leetcode(力扣) 77. 组合（回溯 & 剪枝-----清晰图解+回溯套路模板）
深度不学习！！的博客
10-24 1293
看一下需要剪掉的部分，当记录数组temp中为空，且当前i取3的时候，剩下可取元素为4，那么取了3再进入一下分支取4，temp中也仅有两个值。首先需要题目给出的n和k没跑了，另外还有一个，可以在图中看到，当选择1之后，只能从2，3，4里再选，选择2之后，只能从剩下的3，4里选，也就是，选择i之后，只能从i+1里去选，所以要有一个记录下标的值startindex。假设n=4，k=4 也就是 一共四个数，取4个数，这里盗用一下卡哥的图，可以看到 除了最左边的一条，其余都不符合要求，都可以剪掉。
数据结构与算法-回溯算法2之Combination Sum
x___xxxx的博客
08-11 221
Combination Sum
组数总和力扣C++
06-01
如果你想在力扣（LeetCode）上实现数组所有元素的总和，可以使用以下代码： ```c++ class Solution { public: int arraySum(vector<int>& nums) { int sum = 0; for (int i = 0; i (); i++) { sum += nums[i]; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值