训练营第二十五天 | ● 216.组合总和III● 17.电话号码的字母组合39. 组合总和 40.组合总和II 131.分割回文串93.复原IP地址 78.子集

最新推荐文章于 2024-06-22 18:11:36 发布
最新推荐文章于 2024-06-22 18:11:36 发布
阅读量895 收藏 28
点赞数 18
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44824156/article/details/139368023
版权

  • 216.组合总和III

剪枝优化如下：

  1. 已经选择的元素个数：path.size();

  2. 所需需要的元素个数为: k - path.size();

  3. 列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）

  4. 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历

题目：

力扣题目链接(opens new window)

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]

示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

思路：

确定参数值：n, k, start（开始标志）

确定终止条件：若sum大于目标和， 或者path.size()大于k，都可以return进行剪枝，若满足要求则将path存入result，再return。

单层搜索过程：用for循环，将值存入path中，并计算sum，然后递归，再pop，特别注意的是pop后，sum还要减去当前的值。

class Solution {
private:
    vector<vector<int>> result;
    int sum = 0;
    vector<int> path;

    void backtracking(int k, int n, int start) {
        // 结束条件
        if (sum > n || path.size() > k) return;
        if (sum == n && path.size() == k) {
            result.push_back(path);
            return;
        }
        
        // 递归过程
        for (int i = start; i <= 9; i++) {
            path.push_back(i);
            sum += i;  // 更新sum
            backtracking(k, n, i + 1);  // 注意：不修改k的值，并且从i+1开始下一层递归
            sum -= i;  
            path.pop_back();  // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear();
        path.clear();
        backtracking(k, n, 1);
        return result;
    }
};

  • 17.电话号码的字母组合

题目：

力扣题目链接(opens new window)

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

17.电话号码的字母组合

示例:

  • 输入："23"
  • 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

思路：

可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射.

二维数组：

const string letterMap[10] = {
    "", // 0
    "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
};

map：

unordered_map<char, string> phoneMap{
            {'2', "abc"},
            {'3', "def"},
            {'4', "ghi"},
            {'5', "jkl"},
            {'6', "mno"},
            {'7', "pqrs"},
            {'8', "tuv"},
            {'9', "wxyz"}
        };

class Solution {
private:
    vector<string> result; // 存储最终结果
    string path; // 存储当前路径
    
    const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz" // 9
    };

    void backtracking(string& digits, int cur) {
        if (cur == digits.size()) {
            result.push_back(path);
            return;
        }
        int digit = digits[cur] - '0'; // 将字符转化为数字
        string letters = letterMap[digit]; // 取数字对应的字符集
        for (char letter : letters) {
            path.push_back(letter); // 添加当前字母到路径
            backtracking(digits, cur + 1); // 递归处理下一个数字
            path.pop_back(); // 回溯
        }
    }

public:
    vector<string> letterCombinations(string digits) {
        if (digits.empty()) return {}; // 如果输入为空，直接返回空结果
        backtracking(digits, 0); // 开始回溯
        return result; // 返回结果
    }
};

力扣题目链接(opens new window)

39. 组合总和

力扣题目链接(opens new window)

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

  • 所有数字（包括 target）都是正整数。
  • 解集不能包含重复的组合。

示例 1：

  • 输入：candidates = [2,3,6,7], target = 7,
  • 所求解集为： [ [7], [2,2,3] ]

示例 2：

  • 输入：candidates = [2,3,5], target = 8,
  • 所求解集为： [ [2,2,2,2], [2,3,3], [3,5] ]

思路：

回溯法回溯三部曲，需要注意 backtracking 函数中的 candidates 参数为传引用（vector<int>& candidates），以避免每次递归时复制整个数组。result、path 和 sum 被定义为类的成员变量，以便在整个类中共享。

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    int sum = 0;
    void backtracking(vector<int>& candidates, int target, int start) { 
        if (sum > target) return;
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = start; i < candidates.size(); i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates, target, 0);
        return result;
    }
};

40.组合总和II

力扣题目链接(opens new window)

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明： 所有数字（包括目标数）都是正整数。解集不能包含重复的组合。

  • 示例 1:
  • 输入: candidates = [10,1,2,7,6,1,5], target = 8,
  • 所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

思路：

该题比上一题多了个去重的操作，所以先给数组排序，然后在横向循环时跳过重复的元素。但需要注意：

  1. 避免越界检查：在循环中对 candidates[i - 1] 进行访问时，应该在访问之前加上 i > start 的检查，以避免越界访问。
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& candidates, int target, int start) {
        if (sum > target) return;
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = start; i < candidates.size(); i++) {
            if (i > start && candidates[i] == candidates[i - 1]) continue;
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, i + 1);
            sum -= candidates[i];
            path.pop_back();
        }

    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return result;

    }
};

131.分割回文串

力扣题目链接(opens new window)

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例: 输入: "aab" 输出: [ ["aa","b"], ["a","a","b"] ]

思路：

回溯法，针对横向for循环，选择的第一个区间内含有的字符数依次增大， 纵向的递归则是区间位置依次后移。其中有许多细节需要注意。

1，需要建立一个辅助函数判断字符串是否“回文”。

2，终止条件为startindex == s.size()（不用减1，因为在backtracking(s, i + 1);的过程中startindex已经变成了s.size()）。

3， string str = s.substr(startindex, i - startindex + 1); 再赋值给path时，先定义子字符串。语法：s.substr(startIndex, length)

4， 若字符串不回文， 一定要用“else continue” 跳过。

class Solution {
private:
 bool isPalindrome(const string& s, int start, int end) {
     for (int i = start, j = end; i < j; i++, j--) {
         if (s[i] != s[j]) {
             return false;
         }
     }
     return true;
 }
    vector<vector<string>> result;
    vector<string> path;
    void backtracking(string s, int startindex) {
        if (startindex == s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startindex; i < s.size(); i++) {
             if (isPalindrome(s, startindex, i)) {
                string str = s.substr(startindex, i - startindex + 1);
                path.push_back(str);               
             }
             else continue;
             backtracking(s, i + 1);
             path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

93.复原IP地址

力扣题目链接(opens new window)

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效的 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效的 IP 地址。

示例 1：

  • 输入：s = "25525511135"
  • 输出：["255.255.11.135","255.255.111.35"]

示例 2：

  • 输入：s = "0000"
  • 输出：["0.0.0.0"]

思路：

这道题目和“分割回文串”的解题思路相似，只是多了许多剪枝操作，

path.size()>4, 可以直接return；

因为数字最多三位数，所以i < startindex + 3;

避免前导零时，注意要保证其是非一位数。

然后，用stoi（）函数将字符转换为数字。在主函数中，只处理字符串位数在[4， 12]之间的.

class Solution {
private:
    vector<string> result;
    vector<string> path;

    void backtracking(string s, int startindex) {
        if (startindex == s.size() && path.size() == 4) {
            result.push_back(path[0] + '.' + path[1] + '.' + path[2] + '.' + path[3]);
            return;
        }
        if (path.size() > 4) {
            return;
        }
        for (int i = startindex; i < s.size() && i < startindex + 3; i++) {
            if (s[startindex] == '0' && i > startindex) continue;  
           // 避免前导零,需要保证非一位数
            string str = s.substr(startindex, i - startindex + 1);
            int num = stoi(str);
            if (num > 255) continue;  // 检查范围
            path.push_back(str);
            backtracking(s, i + 1);
            path.pop_back();
        }
    }

public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        path.clear();
        if (s.size() >= 4 && s.size() <= 12) {
            backtracking(s, 0);
        }
        return result;
    }
};

78.子集

力扣题目链接(opens new window)

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [ [3],   [1],   [2],   [1,2,3],   [1,3],   [2,3],   [1,2],   [] ]

思路：

回溯三部曲，只是result收集的是每个子节点，所以result收集结果放在终止条件以前，其中因为i<nums.size()已经限制了循环，所以上面的终止条件可以不写。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

90.子集II

力扣题目链接(opens new window)

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

  • 输入: [1,2,2]
  • 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

思路：

该题相较于上题多了一个去重的操作，所以需要保证在横向for循环（即同一层级）跳过重复元素。

注意：

只跳过同一层级的重复元素，而不是整个数组的。为此，需要确保在检查重复元素时，判断是否是同一层级的元素。将 if (i > 0 && nums[i] == nums[i - 1]) 改为 if (i > startindex && nums[i] == nums[i - 1])，这样可以跳过当前层级的重复元素。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startindex) {
        result.push_back(path);
        for (int i = startindex; i < nums.size(); i++) {
            if (i > startindex && nums[i] == nums[i - 1]) continue;  
            // 只跳过当前层级的重复元素
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());  // 排序以便检测重复元素
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

491.递增子序列

力扣题目链接(opens new window)

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

  • 输入: [4, 6, 7, 7]
  • 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

  • 给定数组的长度不会超过15。
  • 数组中的整数范围是 [-100,100]。
  • 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

思路：

这道题需要两个元素以上，给个if语句判断，再收集结果。然后就是需要确保递增顺序：

if (path.empty() || nums[i] >= path.back())。注意判断是否为空。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startindex) {
        if (path.size() > 1) result.push_back(path);
        for (int i = startindex; i < nums.size(); i++) {
            if (i > startindex && nums[i] == nums[i - 1]) continue;  // 跳过重复元素
            if (path.empty() || nums[i] >= path.back()) {  // 确保递增顺序
                path.push_back(nums[i]);
                backtracking(nums, i + 1);
                path.pop_back();
            }
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

weixin_44824156
关注
  • 18
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-leetcode面试题解之第39题组合总和-python题解.zip
03-12
python python_leetcode面试题解之第39题组合总和_python题解
python-leetcode面试题解之第216题组合总和III-题解.zip
05-28
python python_leetcode面试题解之第216题组合总和III_题解
BraveheartHui#leetcode#261. 组合总和III1
07-25
题目描述思路思路与“40. 组合总和III”类似，多一个判断cnt是否与给定k相等的剪枝过程。
Python算法题源代码-LeetCode(力扣)-组合总和
02-29
39. 组合总和 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ， 并以列表形式返回。你可以按 任意顺序 返回这些组合。 ...
XYShaoKang#sk-js-algorithm#39.组合总和1
07-25
39.组合总和* [39] 组合总和解法 1: 动态规划原本想的是用 DFS,不过需要去重,太麻烦了,然后用动态规划试了下,直接过了for (const num
排序（3）【归并排序】【计数排序】【排序算法度及其稳定性分析】
2301_81699364的博客
06-19 551
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
*算法训练（leetcode）第十四天 | 513. 找树左下角的值、112. 路径总和、106. 从中序与后序遍历序列构造二叉树、D
weixin_43872997的博客
06-21 1127
LeetCode刷题日记
算法训练营day62
stmfresher的博客
06-17 193
在上一题的基础上加了一个，map确定 数组num1里元素最右边的值。真 暴力解法，但会超时。
C语言期末习题（结构体开始）
Mr_Xuhhh的博客
06-18 853
包含内容：结构体，枚举，联合体，动态内存管理，宏定义，编译，链接，预处理等相关知识，以题目的方式带着复习知识点，加油，相信一定对你有很大收获
（分治算法3）leecode 53 最大子数组和（最大子段和）
h201601060805的博客
06-17 192
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。对于跨越两个数组的情况，我们可以从中间一定要包含左边界的数字或者右边界的数字，只需要一次遍历就可以了。这个问题可以分成从左半边数组找最大子段和从右半部分找最大子段和。子数组是数组中的一个连续部分。
代码随想录算法训练营第四十一天| 416. 分割等和子集
qq_44388663的博客
06-18 186
题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/description/文章链接：https://programmercarl.com/0416.%E5%88%86%E5%89%B2%E7%AD%89%E5%92%8C%E5%AD%90%E9%9B%86.html。
【CT】LeetCode手撕—415. 字符串相加
weixin_44382896的博客
06-21 289
【代码】【CT】LeetCode手撕—415. 字符串相加。
【做一道算一道】零钱兑换
a_golden_fish的博客
06-18 683
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。你可以认为每种硬币的数量是无限的。
Day55 代码随想录打卡|二叉树篇---二叉搜索树中的插入操作
m0_48909584的博客
06-19 507
方法：本题是为一个二叉搜索树加入一个新的值，题目中说可以重构二叉树，但其实没有必要，我们只需要对现有的二叉树进行遍历，把值插在某个节点的孩子节点上就可以了。即不改变原有二叉树的初始结构，只是单纯的加入一个新的节点。3：单层处理逻辑：单层递归时我们需要判断当前root的val值与我们将要插入的val值的大小，如果val>root->val，那么遍历该root的右子树，如果val<root->val，那么遍历该root的左子树。1：传入参数与返回值：首先传入的肯定树的节点指针，其次要传入我们要插入的值。
K-MEANS 算法的简单实现
Go_ahead_forever的博客
06-17 333
K-MEANS 算法的简单实现
树结构与算法-杨辉三角形的两种实现
qq_36115196的博客
06-17 388
杨辉三角形的两种实现方式
力扣719.找出第K小的数对距离
Pisasama的博客
06-17 408
【代码】力扣719.找出第K小的数对距离。
力扣1504.统计全1子矩形
最新发布
Pisasama的博客
06-22 135
开一个二维数组存每个点。
*算法训练（leetcode）第十天 | 150. 逆波兰表达式求值、239. 滑动窗口最大值、*347. 前 K 个高频元素
weixin_43872997的博客
06-17 890
LeetCode刷题日记
python组合总和
09-16
Python中求解组合总和可以使用回溯法来实现。下面是一个示例代码： ```python def combinationSum(candidates, target): res = [] candidates.sort() # 将candidates排序，方便后面剪枝 def backtrack(start, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值