leetcode打卡-回溯I

已于 2023-03-02 00:28:23 修改
阅读量255 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 算法 职场和发展
于 2023-02-25 23:42:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43093878/article/details/129222134
版权

77. 组合

leetcode题目链接：https://leetcode.cn/problems/combinations/

leetcode AC记录：

代码如下：

public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        hs(res, path, 1, k,n);
        return res;
    }

    public void hs(List<List<Integer>> res, List<Integer> path, int begin, int k, int n) {
        if(path.size() == k) {
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i = begin; i <= n;i++) {
            path.add(i);
            hs(res, path, i+1, k, n);
            path.remove(path.size()-1);
        }
    }

216.组合总和III

leetcode题目链接：https://leetcode.cn/problems/combination-sum-iii

leetcode AC记录：

代码如下：

 public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        combain(res, path, 0, k, n, 1);
        return res;
    }

    public void combain(List<List<Integer>> res, List<Integer> path, int sum, int k, int n, int begin) {
        if(sum == n && path.size() == k) {
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i = begin;i <= 9;i++) {
            path.add(i);
            combain(res, path, sum+i, k, n, i + 1);
            path.remove(path.size()-1);
        }
    }

17.电话号码的字母组合

leetcode题目链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/

leetcode AC记录：

代码如下：

class Solution {
    public List<String> letterCombinations(String digits) {
        if(digits == null || digits.length() == 0) {
            return new ArrayList<>(0);
        }
        List<String> res = new ArrayList<>(16);
        String path = "";
        hs(res, path, 0, digits.length(), 0, digits);
        return res;
    }

    public void hs(List<String> res, String path, int curSize, int size, int beginNum, String digits) {
        if(curSize == size) {
            res.add(path);
            return;
        }

        char c = digits.charAt(beginNum);
        char[] str = getArray(c);
        for(int i = 0;i < str.length;i++) {
            hs(res, path + str[i], curSize + 1, size, beginNum + 1, digits);
        }
    }

    public char[] getArray(char c) {
        switch(c) {
            case '2':
                return "abc".toCharArray();
            case '3':
                return "def".toCharArray();
            case '4':
                return "ghi".toCharArray();
            case '5':
                return "jkl".toCharArray();
            case '6':
                return "mno".toCharArray();
            case '7':
                return "pqrs".toCharArray();
            case '8':
                return "tuv".toCharArray();
            case '9':
                return "wxyz".toCharArray();
        }
        return null;
    }
}

39.组合总和

leetcode题目链接：https://leetcode.cn/problems/combination-sum

leetcode AC记录：

代码如下：

public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        reverse(res, path, candidates, target, 0, 0);
        return res;
    }

    public void reverse(List<List<Integer>> res, List<Integer> path, int[] candidates, int target, int begin, int sum) {
        if(sum == target) {
            res.add(new ArrayList<>(path));
            return;
        } else if(sum > target) {
            return;
        }

        for(int i = begin;i < candidates.length;i++) {
            // while(sum <= target) {
                path.add(candidates[i]);
                reverse(res, path, candidates, target, i, sum + candidates[i]);
                path.remove(path.size()-1);
            // }
        }
    }

 40. 组合总和 II

leetcode题目链接：https://leetcode.cn/problems/combination-sum-ii/

leetcode AC记录：

思路：去重分两部分，一个是数组需要先进行排序，第二个是使用数组记录递归中同一层的相同元素是否已经使用，如果已经使用，则说明两个元素相同，都参与了结果组成，如果不相同，则说明当前元素和之前元素相同，是相同的结果集，跳过不处理。

代码如下：

public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        Arrays.sort(candidates);
        System.out.println(Arrays.toString(candidates));
        boolean[] used = new boolean[candidates.length];
        combain(res, used, path, candidates, target, 0, 0);
        return res;
    }

    public void combain(List<List<Integer>> res, boolean[] used,List<Integer> path, int[] candidates, int target, int sum, int begin) {
        if(sum == target) {
            res.add(new ArrayList<>(path));
            return;
        } else if(sum > target) {
            return;
        }


        for(int i = begin; i < candidates.length; i++) {
            if(i > 0 && candidates[i] == candidates[i-1] && !used[i-1]) {
                continue;
            }

            path.add(candidates[i]);
            used[i] = true;
            combain(res, used, path, candidates, target, sum + candidates[i], i + 1);
            used[i] = false;
            path.remove(path.size()-1);
        }
    }

131. 分割回文字符串

leetcode题目链接：https://leetcode.cn/problems/palindrome-partitioning 

leetcode AC记录：

思路：使用begin当作要切割的起点，使用i表示切割的长度，进行回溯即可。

代码如下：

public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>(16);
        List<String> path = new ArrayList<>(16);
        reverse(res, path, 0, s, 0);
        return res;
    }


    public void reverse(List<List<String>> res, List<String> path, int length, String s, int begin) {
        if(length >= s.length()) {
            res.add(new ArrayList<>(path));
        }

        for(int i = 0;i < s.length();i++) {
            if(begin + i + 1 > s.length()) {
                continue;
            }
            String str = s.substring(begin, begin + i + 1);
            if(isHuiwen(str)) {
                path.add(str);
                reverse(res, path, begin + i + 1, s, begin + i + 1);
                path.remove(path.size()-1);
            }
        }
    }

    public boolean isHuiwen(String str) {
        int begin = 0;
        int end = str.length()-1;
        while(begin <= end) {
            if(str.charAt(begin) != str.charAt(end)) {
                return false;
            }
            begin++;
            end--;
        }

        return true;
    }

93.复原IP地址

leetcode题目链接：https://leetcode.cn/problems/restore-ip-addresses/

leetcode AC记录：

思路：使用begin代表需要分割的开始位置，i代表分割的长度，如果path链表长度超过4，直接返回。

代码如下：

public List<String> restoreIpAddresses(String s) {
        List<String> res = new ArrayList<>(16);
        List<String> path = new ArrayList<>(16);
        huisu(s, res, path, 0, 0);
        return res;
    }

    public void huisu(String s, List<String> res, List<String> path, int begin, int length) {
        if(length == s.length() && path.size() == 4) {
            res.add(path.stream().collect(Collectors.joining(".")));
            return;
        } else if(length > s.length()  || path.size() > 4) {
            return;
        }

        for(int i = 0;i < s.length();i++) {
            if(begin + i + 1 > s.length()) {
                continue;
            }
            int num = isValid(s.substring(begin, begin + i + 1));
            if(num != -1) {
                path.add(String.valueOf(num));
                huisu(s, res, path, begin + i +1, begin + i + 1);
                path.remove(path.size()-1);
            }
        }
    }


    //返回-1说明不合法
    public int isValid(String s) {
        //判断首位是否为0
        boolean zeroFisrst = s.charAt(0) == '0';
        if(zeroFisrst && s.length() > 1) {
            return -1;
        }
        //判断是否为纯数字
        int res = 0;
        int js = 1;
        for(int i = s.length() -1; i >= 0 ;i--) {
            char c = s.charAt(i);
            if('0' > c || c > '9') {
                return -1;
            }

            res += js * (c - '0');
            js *= 10;
        }

        return res >= 0 && res <= 255 ? res : -1;
    }

78.子集

leetcode题目链接：https://leetcode.cn/problems/subsets/ 

leetcode AC记录：

代码如下：

public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);

        huisu(res, path, nums, 0);
        return res;
    }

    public void huisu(List<List<Integer>> res, List<Integer> path, int[] nums, int begin) {
        if(path.size() <= nums.length) {
            res.add(new ArrayList<>(path));
        }

        for(int i = begin;i < nums.length;i++) {
            path.add(nums[i]);
            huisu(res, path, nums, i + 1);
            path.remove(path.size()-1);
        }
    }

90.子集II

leetcode题目链接：https://leetcode.cn/problems/subsets-ii/submissions 

leetcode AC记录：

代码如下：

public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        hs(res, path, nums, used, 0);
        return res;
    }

    public void hs(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used, int begin) {
        if(path.size() <= nums.length) {
            res.add(new ArrayList<>(path));
        }

        for(int i = begin;i < nums.length;i++) {
            if(i > 0 && nums[i-1] == nums[i] && !used[i-1]) {
                continue;
            }

            path.add(nums[i]);
            used[i] = true;
            hs(res, path, nums, used, i + 1);
            path.remove(path.size()-1);
            used[i] = false;
        }
    }

 491.递增子序列

leetcode题目链接：https://leetcode.cn/problems/non-decreasing-subsequences

leetcode AC 记录： 

思路：回溯同一层中不能有重复的，使用set进行去重。

代码如下：

public List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);

        hs(res, path, nums, 0);
        return res;
    }

    public void hs(List<List<Integer>> res, List<Integer> path, int[] nums, int begin) {
        if(path.size() > 1) {
            res.add(new ArrayList<>(path));
        }

        Set<Integer> set = new HashSet<>(16);       
        for(int i = begin;i < nums.length;i++) {
            if(set.contains(nums[i])) {
                continue;
            }

            if(path.size() == 0 || path.get(path.size()-1) <= nums[i]) {
                set.add(nums[i]);
                path.add(nums[i]);
                hs(res, path, nums, i + 1);
                path.remove(path.size()-1);

            }
        }
    }

 46.全排列

leetcode题目链接：https://leetcode.cn/problems/permutations/

leetcode AC记录：

思路：回溯的时候，使用数组记录是否已经使用过，都是从0开始遍历。

代码如下：

public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        boolean[] used = new boolean[nums.length];
        hs(res, path, nums, used);
        return res;
    }

    public void hs(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used) {
        if(path.size() >= nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length;i++) {
            if(used[i]) {
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            hs(res, path, nums, used);
            path.remove(path.size()-1);
            used[i] = false;
        }
    }

 47.全排列 II

leetcode题目链接：https://leetcode.cn/problems/permutations-ii

leetcode AC记录：

思路：使用数组记录有没有使用过，去重使用数组排序，如果回溯的本层将要使用的元素和下标减1位置处的元素相同，代表是重复的结果集，跳过不处理。

代码如下：

 public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(16);
        List<Integer> path = new ArrayList<>(16);
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        hs(res, path, nums, used);
        return res;
    }

    public void hs(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used) {
        if(path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i = 0;i < nums.length;i++) {
            if(used[i]) {
                continue;
            }

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

            used[i] = true;
            path.add(nums[i]);
            hs(res, path, nums, used);
            path.remove(path.size()-1);
            used[i] = false;
        }
    }

 

川夜施密特
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode打卡-回溯II
川夜施密特的博客
03-03 127
回溯，leetcode困难
【LeetCode】-回溯算法
银尘博客
03-22 2251
文章目录前言一、组合 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、组合 题目： 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3],
leetcode打卡-二叉树II
川夜施密特的博客
02-25 159
leetcode打卡：二叉树II
leetcode打卡--282. 给表达式添加运算符【关于回溯的模拟题】
CppYyds的博客
10-17 209
文章目录题目题目解析解题代码 题目 题目描述 给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回所有能够得到目标值的表达式。 示例1： 示例2： 示例3： 示例4： 示例5： 题目解析 题目描述很简单，就是给出一个字符串，和一个需要的值，给字符串固定位置添加运算符得出表达式，如果表达式的结果是给出的值，就加入答案，要求出所有这样的字符串。 我们很快想到用回溯的方式，每一层枚举计算的式子的每一
leetcode卡-leetcode:leetcode打卡
07-06
在LeetCode的日常打卡过程中，你可能会遇到以下知识点： 1. **数据结构**：链表、树、堆、栈、队列、哈希表、图等，这些都是LeetCode中常见的题目背景，理解和熟练运用这些数据结构是解决问题的关键。 2. **排序与...
leetcode下载--leetcode:-leetcode
06-29
哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。 但我能设身处地的感受到：即使有这样一个整体规划，对于一位初学者...
leetcode跳跃-LeetCode:LeetCode刷题打卡
06-30
LeetCode刷题打卡 2020.02.04 回溯算法 编号 难度 题目 题解思路 执行结果 401 简单 二进制手表 回溯算法 40 ms 13.2 MB 784 简单 字母大小写全排列 回溯算法 64 ms 13.5 MB 2020.02.05 数组 编号 难度 题目 题解...
leetcode卡-LeetCode:力扣打卡
07-06
"LeetCode卡"可能指的是用户在LeetCode上进行日常练习的一种方式，类似于学习或打卡计划。 在LeetCode的开源项目"LeetCode-master"中，我们可能找到一个与LeetCode平台相关的代码库，它可能是为了帮助用户更方便地...
leetcode卡-java-leetcode:leetcode算法学习打卡
07-06
这个“leetcode卡-java-leetcode:leetcode算法学习打卡”项目似乎是一个针对Java开发者的LeetCode学习资源，它可能包含了代码示例、解题策略以及每日学习计划。"系统开源"的标签表明该项目是开放源代码的，这意味着...
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 166
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 3161
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
每日一题，力扣leetcode Hot100之283. 移动零
u013373155的博客
07-19 134
首先，两个指针都指向同一个位置，i=j=0，如果移动指针i的位置不为0则进行交换，固定指针+1，如果为0的话，固定指针不变，移动指针往后面移一直找。这样的话固定指针就会指在0的位置，相当于移动指针遇到非0就和0进行交换。对于当前数组进行调整，不使用额外空间，那么既用双指针。
力扣88.合并两个有序数组（Java）
2301_80369371的博客
07-16 161
一般两个有序数组合并，都是从后往前赋值，因为两个数组中的最大值相比较出来的最大值，就是合并后的最大值，所以可以直接丢在最后面，然后如此类推，直到某一个数组被比较完，如果是第一个数组，则只需要将第二个数组剩下的直接赋值过去即可；如果是第二个数组，则不用管了，因为前面放的就是第一个数组的值。同时注意特殊情况，如果第一个数组的有效值为0个，合并后就是第二个数组，则只需要将第二个数组复制给第一个数组即可；如果第二个数组的有效值为0个，则不需要进行任何操作，合并后就是第一个数组。
力扣第七题——整数反转
m0_74932528的博客
07-15 416
/ 方法体这里定义了一个名为Solution的类，以及一个reverse方法，该方法接收一个整数x作为参数，并返回一个整数。
Leetcode 1302.层数最深子叶结点的和
m0_54244065的博客
07-18 636
大家好，今天我给大家分享一下我关于这个题的想法，我这个题过程比较复杂，但大家如果觉得好的话，就请给个免费的赞吧，谢谢了^ _ ^ 1.题目要求: 举例如图所示: 2.做题思路: 1.先用前序遍历求出树的结点数量: 2.然后再根据结点数量用malloc分配两个数组，一个要进行层序遍历，一个要记录树每一层的宽度: 3.然后我们进行层序遍历,设置变量把每一行结点的数量记录下来，再把每个结点存入数组中: 3.全部代码: 好了，这就是我全部代码大家如果觉得好的话，就请给个免费的赞吧，谢谢了^ _ ^ .
Leetcode3208. 交替组 II
最新发布
ProgramNovice的博客
07-19 118
Leetcode3208. 交替组 II
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 737
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
LeetCode第501题：二叉搜索树中的众数的Java实现
2301_77695569的博客
07-19 352
LeetCode第501题要求在二叉搜索树（BST）中找出出现次数最多的元素。本文将介绍两种Java实现方法：迭代法和递归法。
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值