力扣题解 回溯算法（2）

最新推荐文章于 2024-08-22 17:27:46 发布
最新推荐文章于 2024-08-22 17:27:46 发布
阅读量63 收藏
点赞数
分类专栏： C++刷题 文章标签： 算法 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50050499/article/details/124745862
版权
本文通过四个经典的编程题目，详细介绍了如何利用回溯算法解决分割回文串、复原IP地址、子集生成和有重复元素的子集生成问题。每个题目都深入剖析了算法思路，包括关键步骤、递归终止条件、子串截取和回文判断等，并展示了C++实现代码。此外，还讨论了去重策略在子集II问题中的应用。
摘要由CSDN通过智能技术生成

131.分割回文串

总结：

锻炼思考能力，每个步骤是什么。

判断布尔条件放在循环外面。

我列出如下几个难点：

  • 切割问题可以抽象为组合问题
  • 如何模拟那些切割线
  • 切割问题中递归如何终止
  • 在递归循环中如何截取子串
  • 如何判断回文
class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经填在的子串
        }
    }
    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;
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

93.复原IP地址

总结：只判断第四端子端是否合法，根据是否插入记录结果。

好吧 大于255；

  class Solution {
    private:
        vector<string> result;// 记录结果
        // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
        void backtracking(string& s, int startIndex, int pointNum) {
            if (pointNum == 3) { // 逗点数量为3时，分隔结束
                // 判断第四段子字符串是否合法，如果合法就放进result中
                if (isValid(s, startIndex, s.size() - 1)) {
                    result.push_back(s);
                }
                return;
            }
            for (int i = startIndex; i < s.size(); i++) {
                if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                    s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                    pointNum++;
                    backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
                    pointNum--;                         // 回溯
                    s.erase(s.begin() + i + 1);         // 回溯删掉逗点
                } else break; // 不合法，直接结束本层循环
            }
        }
        // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
        bool isValid(const string& s, int start, int end) {
            if (start > end) {
                return false;
            }
            if (s[start] == '0' && start != end) { // 0开头的数字不合法
                    return false;
            }
            int num = 0;
            for (int i = start; i <= end; i++) {
                if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
                    return false;
                }
                num = num * 10 + (s[i] - '0');
                if (num > 255) { // 如果大于255了不合法
                    return false;
                }
            }
            return true;
        }
    public:
        vector<string> restoreIpAddresses(string s) {
            result.clear();
            if (s.size() > 12) return result; // 算是剪枝了
            backtracking(s, 0, 0);
            return result;
        }
    };

78.子集

总结： 每次储存不会

判断语句是，索引大于 数组个数。



    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

总结：

C++ 11 为 STL 标准库增添了 4 种无序（哈希）容器，前面已经对 unordered_map 和 unordered_multimap 容器做了详细的介绍，本节再讲解一种无序容器，即 unordered_set 容器。

unordered_set 容器，可直译为“无序 set 容器”，即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。

总的来说，unordered_set 容器具有以下几个特性：

  1. 不再以键值对的形式存储数据，而是直接存储数据的值；
  2. 容器内部存储的各个元素的值都互不相等，且不能被修改。
  3. 不会对内部存储的数据进行排序（这和该容器底层采用哈希表结构存储数据有关，可阅读《C++ STL无序容器底层实现原理》一文做详细了解）；

迭代法

  1. #include <unordered_set>
  2. using namespace std;

去重复逻辑，

if (i > startIndex && nums[i] == nums[i - 1] ) {
	continue;
}

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path);
        unordered_set<int> uset;
        for (int i = startIndex; i < nums.size(); i++) {
            if (uset.find(nums[i]) != uset.end()) {
                continue;
            }
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0);
        return result;
    }
};



class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0, used);
        return result;
    }
};



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] ) { // 注意这里使用i > startIndex
                continue;
            }
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0);
        return result;
    }
};

491. 递增子序列

    vector::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);
        }
        int used[201] = {0}; // 这里使用数组来进行去重操作，题目说数值范围[-100, 100]
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || used[nums[i] + 100] == 1) {
                    continue;
            }
            used[nums[i] + 100] = 1; // 记录这个元素在本层用过了，本层后面不能再用了
            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;
    }
};
RL-UAV
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
力扣递归回溯题解
m0_50013824的博客
08-26 179
78.子集 class Solution { List<List<Integer>> res = new ArrayList<>(); LinkedList<Integer> path = new LinkedList<>(); public List<List<Integer>> subsets(int[] nums) { if(nums.length == 0){ ...
leetcodehot：存储力扣100热题解
03-03
1. **算法基础**：包括排序、搜索、图论、动态规划、回溯、贪心策略等。每个题目都可能涉及到一种或多种算法，掌握这些基础算法是解决问题的关键。 2. **数据结构**：如数组、链表、栈、队列、哈希表、二叉树等。...
力扣题解 回溯算法（1）
weixin_50050499的博客
05-13 90
力扣题解 回溯算法（1）
力扣题解 回溯算法（3）
weixin_50050499的博客
05-13 74
力扣题解 贪心算法（3）
python 回溯算法 力扣题解
yang_gor_1024的博客
11-11 158
python 回溯算法力扣 37. 解数独 力扣 37. 解数独 class Solution: def solveSudoku(self, board: List[List[str]]) -> None: """ Do not return anything, modify board in-place instead. """ target = [] row = {} col = {}
LeetCode 力扣算法题解汇总，All in One
热门推荐
负雪明烛
12-20 1万+
我刷过的所有 leetcode 算法题解的汇总。 题目的排列顺序是按照先Easy再Medium再Hard排列的，暂时还没有把题目全部整理完成。后序我会把刷过的所有的题目都整理到这个文档里。 如果想看我全部的力扣算法题解，可以看我的题解博客：[fuxuemingzhu.cn](fuxuemingzhu.cn)
力扣题之回溯算法
qq_44807946的博客
05-19 169
回溯算法，更新中......
力扣题解——77. 组合（回溯）
qq_53421929的博客
10-31 431
93. 复原 IP 地址93. 复原 IP 地址二级目录三级目录 93. 复原 IP 地址 二级目录 三级目录
力扣刷题系列——回溯算法I
qq_43568704的博客
08-25 1200
回溯算法思想及经典例题（一） 回溯法 可以提前看看公众号文章：https://mp.weixin.qq.com/s/g5uvxi1lyxmWC4LtP0Bdlw（从二叉树遍历到回溯算法，包含例题：二叉树路径和等于给定目标值的路径（力扣113）、集合的所有子集合列表（力扣78）） 1、概念 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。 回溯法是一种选优搜索法，按选优条件向前搜索，以达到...
力扣算法回溯篇：全排列
qq_22494201的博客
09-15 149
回溯三部曲： 1、确定回溯函数参数 需要一个数组标记某元素已经使用过，used void backtracking(vector<int>& nums,vector<int>& used) 2、确定递归终止条件 当收集元素大小等于nums.size()时，即可停止 3、确定单层搜索过程 for循环控制横向遍历 但不需要startIndex了，因为排列问题都次都要从头开始搜索，然后仍然是递归控制纵向遍历 题解： class Solution { public: .
力扣题解大全-600多页版
08-29
这个“力扣题解大全-600多页版”显然是一个全面整理了力扣平台上众多题目的资源，涵盖了从基础到中高级的算法和数据结构的应用。以下是一些关键知识点的概述： 1. **基本算法**：包括二进制操作（如题目1022），...
leetcode中国-leetcode:力扣中国题解
06-29
力扣中国，又名LeetCode China，是一个深受程序员喜爱的在线编程挑战平台，专注于提高编程技能和算法理解。它提供了一系列的编程题目，涵盖了数据结构、算法、操作系统、计算机网络等多个计算机科学和技术领域。"日...
leetcode答案-leetcode:力扣题目答案
06-30
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，旨在帮助程序员提升技能，准备面试，并在解决问题的过程中学习新的算法和数据结构。这个压缩包"leetcode-master"很可能包含了一个GitHub仓库，该仓库集成了...
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 622
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 710
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 387
哈希表解决存在重复元素二问题
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 910
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
力扣 回溯算法 java
10-18
力扣是一个在线编程平台，提供了大量的算法题目，可以帮助程序员提高算法能力。回溯算法是一种搜索算法，它通过不断地尝试所有可能的解来求解问题。在回溯算法中，我们首先定义一个解空间，然后从解空间中搜索所有可能的解，直到找到符合要求的解为止。回溯算法通常用于求解组合问题、排列问题、子集问题等。 在 Java 中实现回溯算法，通常需要定义一个递归函数来搜索解空间。在递归函数中，我们首先判断当前状态是否符合要求，如果符合要求，则将当前状态加入到解集中；否则，我们继续搜索下一个状态。在搜索下一个状态时，我们需要对当前状态进行一些修改，然后递归调用自身来搜索下一个状态。当搜索完所有可能的状态后，我们需要回溯到上一个状态，继续搜索其他可能的状态。 以下是回溯算法的一般步骤： 1. 定义解空间：确定问题的解空间，并定义一个数据结构来表示解空间中的每个状态。 2. 确定约束条件：确定哪些状态是合法的，并定义一个函数来判断当前状态是否符合要求。 3. 确定搜索策略：确定搜索解空间的顺序，并定义一个函数来生成下一个状态。 4. 搜索解空间：使用递归函数搜索解空间，如果当前状态符合要求，则将其加入到解集中；否则，继续搜索下一个状态。 5. 回溯：当搜索完所有可能的状态后，回溯到上一个状态，继续搜索其他可能的状态。 以下是一个力扣题目的回溯算法 Java 实现示例： ``` class Solution { List<List<Integer>> res = new ArrayList<>(); List<Integer> path = new ArrayList<>(); public List<List<Integer>> subsets(int[] nums) { dfs(nums, 0); return res; } private void dfs(int[] nums, int start) { res.add(new ArrayList<>(path)); for (int i = start; i < nums.length; i++) { path.add(nums[i]); dfs(nums, i + 1); path.remove(path.size() - 1); } } } ``` 该算法用于求解给定数组的所有子集。在递归函数中，我们首先将当前状态加入到解集中，然后从当前位置开始搜索下一个状态。在搜索下一个状态时，我们将当前元素加入到路径中，并递归调用自身来搜索下一个状态。当搜索完所有可能的状态后，我们需要回溯到上一个状态，继续搜索其他可能的状态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

RL-UAV

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值