算法日记day 26（回溯之子集2|非递减子序列|全排列）

最新推荐文章于 2024-11-14 19:06:32 发布
最新推荐文章于 2024-11-14 19:06:32 发布
阅读量631 收藏 25
点赞数 15
文章标签： 算法 数据结构 leetcode java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74980681/article/details/140845383
版权

一、子集2

题目：

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

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

思路：

与之前的子集不同的是，这个集合中可能会存在重复元素的子集，因此需要进行去重操作，在树形结构中主要的去重在于树层的去重

代码：

class Solution {

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        // 如果数组长度为0，直接返回空集
        if (nums.length == 0) {
            result.add(path); // 添加空集
            return result;
        }

        Arrays.sort(nums); // 先排序数组
        used = new boolean[nums.length]; // 初始化used数组
        subsets(nums, 0); // 生成子集
        return result;
    }

    private void subsets(int[] nums, int startIndex) {
        // 每次递归开始时，将当前路径加入结果集
        result.add(new ArrayList<>(path));

        // 从startIndex开始遍历nums数组
        for (int i = startIndex; i < nums.length; i++) {
            //去重操作，如果当前元素与前一个元素相同，且前一个元素未被使用，则跳过
            if (i > startIndex && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue;
            }

            // 添加当前元素到路径中
            path.add(nums[i]);
            //当前元素已经被使用过
            used[i] = true;

            // 递归处理下一个元素
            subsets(nums, i + 1);

            // 回溯，撤销选择
            path.removeLast();
            //path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

  1. subsetsWithDup 方法注释：

    • if (nums.length == 0): 如果数组为空，直接返回包含空集的结果。
    • Arrays.sort(nums): 对数组进行排序，为后续去重处理做准备。
    • used = new boolean[nums.length]: 初始化 used 数组，用于标记每个元素是否已经被选择过。
    • subsets(nums, 0): 调用递归方法开始生成子集。

  2. subsets 方法注释：

    • result.add(new ArrayList<>(path)): 每次递归开始时，将当前路径加入结果集。
    • 循环遍历 nums 数组，从 startIndex 开始。
    • if (i > startIndex && nums[i] == nums[i - 1] && !used[i - 1]): 如果当前元素与前一个元素相同，并且前一个元素未被使用，则跳过，确保不重复生成相同的子集。
    • path.add(nums[i]): 将当前元素加入路径中，标记为已使用。
    • subsets(nums, i + 1): 递归处理下一个元素。
    • path.remove(path.size() - 1): 回溯，撤销当前选择。
    • used[i] = false: 标记当前元素为未使用。

二、非递减子序列

题目：

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

 

思路：

由于数组中存在重复元素，且必须返回至少两个元素的序列，因此对存入的数组需两个以上才可以转存至结果数组中，且去重操作时，若是将对应的整数数组进行排序，可以会造成输出结果的不准确，因此不能对元素的顺序进行修改

代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>(); // 存储所有符合条件的子序列的列表
    LinkedList<Integer> path = new LinkedList<>(); // 当前正在构建的子序列

    // 主函数，找出数组中所有的递增子序列
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0); // 从数组的第一个元素开始进行回溯
        return result; // 返回所有找到的子序列列表
    }

    // 回溯函数，递归找出所有递增子序列
    public void backtracking(int[] nums, int startIndex) {
        if (path.size() >= 2) { // 如果当前路径长度至少为2，将其加入结果列表
            result.add(new ArrayList<>(path));
        }

        HashSet<Integer> hash = new HashSet<>(); // 使用 HashSet 来记录当前递归层级已经使用过的元素

        for (int i = startIndex; i < nums.length; i++) {
            // 跳过违反递增顺序或已经使用过的元素
            if (!path.isEmpty() && path.getLast() > nums[i] || hash.contains(nums[i])) {
                continue;
            }

            hash.add(nums[i]); // 标记 nums[i] 已经使用
            path.add(nums[i]); // 将 nums[i] 加入当前子序列

            // 递归回溯，从下一个索引开始
            backtracking(nums, i + 1);

            path.removeLast(); // 回溯：从当前子序列移除 nums[i]
        }
    }

}

  1. 初始化:

    • List<List<Integer>> result = new ArrayList<>();: 初始化 result 列表，用于存储所有符合条件的子序列。
    • LinkedList<Integer> path = new LinkedList<>();: 初始化 path 链表，用于存储当前正在构建的子序列。

  2. findSubsequences 方法:

    • backtracking(nums, 0);: 从数组 nums 的起始位置开始进行回溯。
    • return result;: 回溯完成后返回所有找到的子序列列表。

  3. backtracking 方法:

    • 基本条件:

      • if (path.size() >= 2) { ... }: 如果当前路径 path 的长度至少为2，则将其加入 result 列表中。

    • 回溯逻辑:

      • HashSet<Integer> hash = new HashSet<>();: 使用 HashSet 来记录当前递归层级已经使用过的元素，避免重复。

      • 遍历 nums 数组:

        • for (int i = startIndex; i < nums.length; i++) { ... }: 从 startIndex 开始遍历 nums 数组。

      • 跳过条件:

        • if (!path.isEmpty() && path.getLast() > nums[i] || hash.contains(nums[i])) { continue; }: 跳过违反递增顺序或已经使用过的元素。

      • 递归步骤:

        • hash.add(nums[i]);: 标记 nums[i] 已经在当前递归层级中使用。
        • path.add(nums[i]);: 将 nums[i] 加入当前正在构建的子序列 path 中。
        • backtracking(nums, i + 1);: 递归调用 backtracking，从下一个索引位置开始继续查找。

      • 回溯操作:

        • path.removeLast();: 回溯操作，从当前子序列 path 中移除最后一个元素 nums[i]。 

在去重逻辑中

if (!path.isEmpty() && path.getLast() > nums[i] || hash.contains(nums[i])) {
    continue;
}

  1. !path.isEmpty() && path.getLast() > nums[i]:

    • !path.isEmpty(): 检查当前路径 path 是否为空，即当前正在构建的子序列是否已经有元素。
    • path.getLast() > nums[i]: 检查当前正在构建的子序列的最后一个元素是否大于当前考虑的 nums[i]。
    • 如果以上两个条件满足，则说明 nums[i] 所在的路径不满足递增要求（因为当前路径的最后一个元素大于 nums[i]），因此应该跳过当前的 nums[i]。

  2. || hash.contains(nums[i]):

    • hash.contains(nums[i]): 使用 HashSet hash 来记录当前递归层级已经使用过的元素。
    • 如果 hash 中已经包含了 nums[i]，则说明 nums[i] 已经在当前路径中出现过，因此也应该跳过当前的 nums[i]。

  3. continue;:

    • 如果以上任何一个条件满足，即当前 nums[i] 不符合递增子序列的要求（要么不大于当前路径的最后一个元素，要么已经在当前路径中出现过），则使用 continue; 跳过当前循环，继续考虑下一个 nums[i]。

三、全排列 

题目：

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

思路：

由于题目要求是输出所有的排列情况，并非组合，因此在循环时必须每个元素都进行标记，直到全部元素都标记完毕时才能输出至结果数组中

代码：

List<List<Integer>> result = new ArrayList<>(); // 用于存储所有排列的结果
LinkedList<Integer> path = new LinkedList<>(); // 当前正在构建的排列
boolean[] used; // 标记每个元素是否已被使用过

public List<List<Integer>> permute(int[] nums) {
    if (nums.length == 0) {
        return result; // 如果数组为空，直接返回空结果列表
    }
    used = new boolean[nums.length]; // 初始化 used 数组
    backtracking(nums); // 开始回溯
    return result; // 返回所有排列的结果
}

public void backtracking(int[] nums) {
    if (path.size() == nums.length) { // 如果当前排列长度等于 nums 的长度
        result.add(new ArrayList<>(path)); // 将当前排列加入结果列表
        return; // 结束当前递归
    }
    for (int i = 0; i < nums.length; i++) { // 尝试每个元素作为下一个排列元素
        if (used[i]) { // 如果元素已被使用过
            continue; // 跳过当前循环
        }
        used[i] = true; // 标记元素为已使用
        path.add(nums[i]); // 将元素加入当前排列
        backtracking(nums); // 递归进入下一层决策树
        used[i] = false; // 回溯，撤销选择
        path.removeLast(); // 移除当前排列的最后一个元素
    }
}

  1. 变量定义：

    • List<List<Integer>> result = new ArrayList<>();: 用于存储所有符合条件的排列的列表。
    • LinkedList<Integer> path = new LinkedList<>();: 当前正在构建的排列。
    • boolean[] used;: 用于标记数组 nums 中的元素是否已经被使用过。

  2. permute 方法：

    • public List<List<Integer>> permute(int[] nums) { ... }
    • 首先检查如果 nums 的长度为0，则直接返回 result，因为没有元素可以排列。
    • 初始化 used 数组，长度与 nums 相同，用来标记每个元素的使用情况。
    • 调用 backtracking(nums) 开始进行排列的回溯过程。
    • 返回 result 列表，其中包含所有的排列结果。

  3. backtracking 方法：

    • public void backtracking(int[] nums) { ... }
    • 基本结束条件：当 path 的长度等于 nums 的长度时，说明已经构建出一个完整的排列，将其加入 result 中。
    • 循环尝试每个元素：
      • 使用 for 循环遍历 nums 数组。
      • 检查 used[i]，如果为 true，说明当前元素已经被使用过，跳过当前循环。
      • 如果 used[i] 为 false，则将 nums[i] 加入 path 中，并标记 used[i] 为 true，表示当前元素已经被使用。
      • 递归调用 backtracking(nums)，继续构建下一个元素的排列。
      • 回溯步骤：将 used[i] 设为 false，表示当前元素未被使用，从 path 中移除最后一个元素，继续尝试其他可能性。

四、全排列2

题目：

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路：

与全排列1类似，但是由于数组中有重复元素，因此需要考虑在树层上的去重问题，判断前后元素是否一致且是否已经标记使用过，如果是，则跳过，否则加入结果中

代码：

class Solution {
    List<List<Integer>> result = new ArrayList<>(); // 存储所有唯一排列的结果
    LinkedList<Integer> path = new LinkedList<>(); // 当前正在生成的排列
    boolean[] used; // 记录每个元素是否已经被使用过

    public List<List<Integer>> permuteUnique(int[] nums) {
        if (nums.length == 0) {
            return result;
        }

        Arrays.sort(nums); // 对数组进行排序，确保相同元素相邻
        used = new boolean[nums.length]; // 初始化used数组，长度与nums相同，初始值均为false
        backtracking(nums); // 调用回溯算法生成排列
        return result;
    }

    public void backtracking(int[] nums) {
        if (path.size() == nums.length) { // 如果当前排列长度等于nums的长度，说明找到了一个全排列
            result.add(new ArrayList<>(path)); // 将当前排列加入结果集合中
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i]) { // 如果当前元素已经被使用过，跳过
                continue;
            }

            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                // 如果当前元素与前一个元素相同，并且前一个元素未被使用，则跳过，避免生成重复的排列
                continue;
            }

            used[i] = true; // 标记当前元素已被使用
            path.add(nums[i]); // 将当前元素加入当前排列
            backtracking(nums); // 递归生成下一个位置的元素
            used[i] = false; // 恢复当前元素为未使用
            path.removeLast(); // 移除当前排列的最后一个元素，回溯到上一个状态
        }
    }
}

  1. 全局变量声明：

    • List<List<Integer>> result = new ArrayList<>();：存储所有唯一排列的结果。
    • LinkedList<Integer> path = new LinkedList<>();：当前正在生成的排列。
    • boolean[] used;：记录每个元素是否已经被使用过的标志数组。

  2. 函数 permuteUnique：

    • if (nums.length == 0)：如果输入数组为空，直接返回 result。
    • Arrays.sort(nums);：对 nums 进行排序，确保相同的元素相邻。
    • used = new boolean[nums.length];：初始化 used 数组，长度与 nums 相同，初始值为 false。
    • backtracking(nums);：调用回溯算法开始生成排列。

  3. 函数 backtracking：

    • if (path.size() == nums.length)：如果当前排列长度等于 nums 的长度，将当前排列加入 result 中。
    • for (int i = 0; i < nums.length; i++)：遍历 nums 数组中的每个元素。
      • if (used[i]) continue;：如果当前元素已经被使用过，跳过。
      • if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;： 如果当前元素与前一个元素相同，并且前一个元素未被使用，则跳过，以避免生成重复的排列。
      • used[i] = true;：标记当前元素为已使用。
      • path.add(nums[i]);：将当前元素加入 path 中。
      • backtracking(nums);：递归生成下一个位置的元素。
      • used[i] = false;：恢复当前元素为未使用。
      • path.removeLast();：移除 path 中的最后一个元素，进行回溯。

 

今天的学习就到这里

day31【代码随想录】回溯之子集||、递增子序列、全排列、全排列||
qq_42338744的博客
12-27 556
1、子集||2、递增子序列3、全排列4、全排列||
算法刷题day22|回溯：491. 非递减子序列、46. 全排列、47. 全排列 II
qq_61936886的博客
07-27 410
本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。这里的set定义在for循环之前，所以在每层回溯的时候都会重置set。可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。。
day29回溯算法part05| 491.递增子序列 46.全排列47.全排列 II
C_huamao的博客
06-10 227
本题和大家刚做过的 90.子集II 非常像，但又很不一样，很容易掉坑里。这题不能直接对初始的序列进行排序，然后去重。题意是要从这个序列里找非递减序列，排序就乱了这里的去重方法是通过，在for之前定义一个哈希表，在每个树层加入path之前先判断之前是否使用过。
算法日记day 25（回溯之分割回文串|复原IP地址|子集）
m0_74980681的博客
07-31 627
关键在于如何判断ip地址是否合法，必须是1到9的数字，每段中不得超过255，且首部不能为0，每遇到一个合法地址必须在其后面加上相应的 '.' 表示分割，由于每种地址最多有3个 '.' 因此可以用一个计数，来判断分割是否完成且合法。确定是否为回文串，定义一个起始索引startIndex从当前索引开始遍历，满足回文条件存入数组中，然后继续递归调用下一层，直到遍历完毕后存入结果数组中并输出。在java中，substring方法用于从字符串中提取子串。，用以表示一个 IP 地址，返回所有可能的。
代码随想录算法day22 | 回溯算法part04 | 491.递增子序列，46.全排列，47.全排列 II
m0_62415132的博客
08-24 939
本题题解清一色都说是深度优先搜索，但我更倾向于说它用回溯法，而且本题我也是完全使用回溯法的逻辑来分析的。相信大家在本题中处处都能看到是 求子集 的身影，但处处又都是陷阱。对于养成思维定式或者套模板套嗨了的同学，这道题起到了很好的警醒作用。更重要的是拓展了大家的思路！每层都是从 0 开始搜索而不是 startIndex需要 used 数组记录 path 里都放了哪些元素了排列问题是回溯算法解决的经典题目，大家可以好好体会体会。continue;continue;
数据结构与算法学习day23-回溯算法-递增子序列、全排列、全排列||
weixin_48990728的博客
09-24 646
给你一个整数数组nums，找出并返回所有该数组中不同的递增子序列，递增子序列中。你可以按返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
【代码随想录训练营】【Day29】第七章｜回溯算法｜491.递增子序列｜46.全排列｜47.全排列 II
士多啤梨先生の博客
03-02 791
【代码随想录训练营】【Day29】第七章｜回溯算法｜491.递增子序列｜46.全排列｜47.全排列 II
代码随想录算法训练营Day 29| 回溯算法part05 | 491.递增子序列、46.全排列、47.全排列 II
m0_51759998的博客
04-28 385
在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。而本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。每层都是从0开始搜索而不是startIndex。需要used数组记录path里都放了哪些元素了。所以不能使用之前的去重逻辑！
Day70 代码随想录打卡|回溯算法篇---递增子序列
m0_48909584的博客
07-16 268
方法：本题要求找到无序数组的所有递增序列，和子集问题的思路有类似。同时本题中的去重的条件不能和之前的used数组方式一样，因为used数组中要求我们的nums数组是有序的，但这和我们本题的条件是冲突的，因此只能用unorderedset的方式来去重。3：单层处理条件：需要我们判断每个元素是否是重复的，如不重复再处理，然后就是基础的回溯。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。2：终止条件：无需终止条件，但需要path的长度大于1才能收集结果。
【代码随想录训练营】【Day28】第七章｜回溯算法｜93.复原IP地址｜78.子集｜90.子集II
士多啤梨先生の博客
03-01 848
【代码随想录训练营】【Day28】第七章｜回溯算法｜93.复原IP地址｜78.子集｜90.子集II
day27-29| 39组合总和40 数组总和II13分割回文串93.复原IP地址78子集90子集II491递增子序列46全排列47全排列II332重新安排行程37解数独
Calliops的博客
06-10 943
通过笔试我还是知道了这个博客要好好写，不然复习起来有点麻烦的子集问题可以不写终止条件的；难的最后三题全部没做，过了题目要求没看暂时 ，来不及了，端午节最后一天了。贪心还没有补呢我真的是要烦死了，在实验室里面睡觉想着不用回宿舍了，节省一点时间，结果被蚊子整的根本睡不好。气死我了。
算法训练Day28 | LeetCode93.复原IP地址（回溯算法中的切割问题2）；78 子集（每个节点都收集结果）；90.子集II（子集问题+去重）
weixin_47284299的博客
11-25 835
算法训练Day28 | LeetCode93.复原IP地址（回溯算法中的切割问题2）；78 子集（每个节点都收集结果）；90.子集II（子集问题+去重）
【代码随想录训练营】【Day30】第七章｜回溯算法｜332.重新安排行程｜51. N皇后｜37. 解数独｜总结
士多啤梨先生の博客
03-03 657
【代码随想录训练营】【Day30】第七章｜回溯算法｜332.重新安排行程｜51. N皇后｜37. 解数独｜总结
java计算文本相似度算法总结
最新发布
sunsiny
11-14 539
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
16 合并区间
weixin_47521269的博客
11-12 726
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1101
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
1-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 131
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1512
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
以太坊系地址衍生算法分层确定性生成逻辑
J_Lee
11-12 240
以太坊系地址衍生算法分层确定性生成逻辑
回溯算法详解：LeetCode中的子集与全排列问题
在这篇文章中，我们将深入探讨如何通过回溯算法来实现两个具体问题的解决方案：**求给定数组的所有子集** 和 **全排列**。 ### 1. **求给定数组的所有子集（无重复）** 题目描述要求我们找出一个不含重复元素的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值