算法练习 Day27 | LeetCode 39,40,131

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量1.2k 收藏 21
点赞数 24
文章标签： 算法 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41582388/article/details/135816065
版权
文章讲述了在LeetCode中的两个问题，39.组合总和和40.组合总和II，涉及使用回溯算法寻找目标和的整数组合，以及131.分割回文串，通过回溯和双指针法确定字符串分割成回文子串的方案。
摘要由CSDN通过智能技术生成

LeetCode 39 ：39.组合总和

题目描述：

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

解题思路：

class Solution {
    private List<List<Integer>> result = new ArrayList();
    private LinkedList<Integer> path = new LinkedList();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtracking(candidates, target, 0);
        return result;
    }

    public void backtracking(int[] candidates, int target, int startIndex){
        //终止条件
        if(sum > target){
            return;
        }
        if(sum == target) {
            result.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex;i<candidates.length;i++){
            sum += candidates[i];
            path.add(candidates[i]);
            //注意此处是i而不是startIndex
            backtracking(candidates, target, i);
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

LeetCode 40：40. 组合总和 II

题目描述：

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

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

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

LeetCode 40：40. 组合总和 II

题目描述：

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

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

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

解题思路：

回溯三要素：

（1）回溯参数及返回值

List<List<Integer>> result = new ArrayList();
LinkedList<Integer> path = new LinkedList();
Integer sum = 0;
//用来存放树层中该值是否使用过
boolean[] used = new boolean[candidates.length];
//先填充false
Arrays.fill(used, false);

public void backtracking(int[] candidates, int target, List<List<Integer>> result, LinkedList<Integer> path, boolean[] used, Integer sum, Integer startIndex) {

（2）终止条件


        if(sum > target) {
            return;
        }
        if(sum == target) {
            result.add(new ArrayList(path));
            return;
        }

（3）单层逻辑

for (int i= startIndex;i<candidates.length;i++) {
            //树层去重
            if(i>0 && candidates[i] == candidates[i-1] && !used[i-1]) {
                continue;
            }
            path.add(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            backtracking(candidates, target, result, path, used, sum, i+1);
            sum -= candidates[i];
            used[i] = false;
            path.removeLast();
        }

关键点：

（1）先排序，如果candidates中i位置和i-1位置的数据相同，则说明重复了

（2）再对树层去重，used[i - 1] == false，说明同一树层candidates[i-1]使用过

完整代码：

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList();
        LinkedList<Integer> path = new LinkedList();
        Integer sum = 0;
        //用来存放树层中该值是否使用过
        boolean[] used = new boolean[candidates.length];
        //先填充false
        Arrays.fill(used, false);
        //对candidates先排序，这样才能对i与i-1位置上的数据进行比较，看是否重复
        Arrays.sort(candidates);
        backtracking(candidates, target, result, path, used, sum, 0);
        return result;
    }

    public void backtracking(int[] candidates, int target, List<List<Integer>> result, LinkedList<Integer> path, boolean[] used, Integer sum, Integer startIndex) {
        //终止条件
        if(sum > target) {
            return;
        }
        if(sum == target) {
            result.add(new ArrayList(path));
            return;
        }
        for (int i= startIndex;i<candidates.length;i++) {
            //树层去重
            if(i>0 && candidates[i] == candidates[i-1] && !used[i-1]) {
                continue;
            }
            path.add(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            backtracking(candidates, target, result, path, used, sum, i+1);
            sum -= candidates[i];
            used[i] = false;
            path.removeLast();
        }
    }
}

具体可参考：代码随想录

 

LeetCode 131：131.分割回文串

题目描述：

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

解题思路：

​

回溯三要素：

（1）参数及返回值

  List<List<String>> result = new ArrayList<>();
  LinkedList<String> path = new LinkedList<>();
  public void backtracking(String s, int startIndex) {

（2）终止条件

//终止条件 - 如果起始位置大于s的长度
if (startIndex >= s.length()) {
    result.add(new ArrayList<>(path));
    return;
 }

（3）单层循环逻辑

for (int i = startIndex;i< s.length();i++) {
            if (isPalindrome(s, startIndex, i)) {
                path.add(s.substring(startIndex,i+1));
            } else {
                continue;
            }
            backtracking(s, i+1);
            path.removeLast();
        }

关键点：

（1）如何切割

startIndex就是切割线，字符串中[startIndex,i]位置上的子串就是切割后的子串

s.substring(startIndex,i+1)

（2）判断回文子串

双指针法判断回文

public boolean isPalindrome(String s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }

 

完整代码：

class Solution {
    List<List<String>> result = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();
    public List<List<String>> partition(String s) {
        backtracking(s, 0);
        return result;
    }
     public void backtracking(String s, int startIndex) {
        //终止条件 - 如果起始位置大于s的长度
        if (startIndex >= s.length()) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex;i< s.length();i++) {
            if (isPalindrome(s, startIndex, i)) {
                path.add(s.substring(startIndex,i+1));
            } else {
                continue;
            }
            backtracking(s, i+1);
            path.removeLast();
        }
    }

    /**
     * 判断是否是回文字符串
     * @param s
     * @param start
     * @param end
     * @return
     */
    public boolean isPalindrome(String s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}

weixin_41582388
关注
算法练习 Day24 | LeetCode 77
weixin_41582388的博客
01-23 452
path数组的大小如果达到k，就说明找到了一个子集大小为k的组合了，此时用result二维数组将path保存起来，并终止本层递归。回溯法也是一种暴力搜索法，一般用来解决组合、切割、子集、排列、棋盘等问题。LeetCode 77: 组合。（1）递归函数的返回值及参数。（1）递归函数的返回值及参数。可以利用回溯法来解决这个问题。（2）回溯函数的终止条件。（2）回溯函数的终止条件。
算法练习 Day25 | LeetCode 216,17
weixin_41582388的博客
01-23 437
该列表不能包含相同的组合两次，组合可以以任何顺序返回。所有可能的有效组合的列表。没有其他符合的组合了。（1）递归参数及返回值。
算法练习 Day2 | LeetCode 977,209,59
weixin_41582388的博客
01-02 482
解题思路：利用双指针，题目中给出的是有序数组，所以最大值不是在数组的最左侧就是在数组的最右侧，所以定义一左一右两个指针，如果左侧的平方大于右侧算出的平方数，则结果数组位置处为左侧数据平方，左指针向右移动一位，反之，则数组位置处为右侧数据平方，右指针向左移动一位。2.窗口的起始位置何时移动：当前窗口中的和≥target了，就可以向前移动，同时将窗口中sum值减去。解题思路：这道题重点在边界问题的处理，采用的是左闭右开。3.窗口的终止位置何时移动：终止位置就是循环中的索引。个正整数的数组和一个正整数。
算法练习 Day27 | leetcode 39. 组合总和，40.组合总和II，131.分割回文串
weixin_63070607的博客
01-25 1316
算法练习 Day27 | leetcode 39. 组合总和，40.组合总和II，131.分割回文串
算法练习 Day14 | LeetCode 144,145,94
weixin_41582388的博客
01-16 357
（2）完全二叉树：一颗深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这颗二叉树称为完全二叉树。（3）二叉搜索树：若它的左子树不空，则左子树上的所有结点的值均小于它的根节点的值；若它的右子树不空，则右子树上所有结点的值均大于他的根节点的值。（4）平衡二叉搜索树：平衡二叉搜索树具有以下性质：它是一颗空树或者它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树。
算法练习 Day1 | LeetCode 704,27
weixin_41582388的博客
12-27 424
解题思路：利用二分查找法，有两种形式，一种左闭右闭，一种左闭右开，需要注意两种形式的边界问题。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。不要使用额外的数组空间，你必须仅使用。，如果目标值存在返回下标，否则返回。总结：在运用二分法时需要注意边界问题。总结：快慢指针在数组及链表中应用较多。的元素，并返回移除后数组的新长度。个元素有序的（升序）整型数组。解题思路：利用快慢指针进行解题。
算法练习 Day39 | LeetCode62,63
weixin_41582388的博客
02-06 853
一个是从（i-1,j）位置向下走一步，另一种是从（i，j-1）位置向右走一步，所以要到达（i，j）位置递推公式：dp[i][j]=dp[i-1][j]+dp[i][j-1]一个是从（i-1,j）位置向下走一步，另一种是从（i，j-1）位置向右走一步，所以要到达（i，j）位置递推公式：dp[i][j]=dp[i-1][j]+dp[i][j-1]dp[i][j]:表示从（0,0）到（i，j）有dp[i][j]条不同的路径。dp[i][j]:表示从（0,0）到（i，j）有dp[i][j]条不同的路径。
算法练习 Day10 | leetcode 232.用栈实现队列，225. 用队列实现栈
weixin_63070607的博客
12-09 145
leetcode 232.用栈实现队列，225. 用队列实现栈
算法练习 Day10 | LeetCode 232,225
weixin_41582388的博客
01-12 1008
利用两个栈来实现，一个栈为stackIn，一个栈为stackOut，先将元素按照顺序压入stackIn中，然后依次弹出再压入stackOut中，再依次将元素弹出，这样就能实现一个队列的需求了。队列： 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First in First out）利用一个队列实现，具体思路是将队列中最后一个元素之前的元素全都弹出，然后再重新压入队列中。请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（
算法训练Day28 | LeetCode93.复原IP地址（回溯算法中的切割问题2）；78 子集（每个节点都收集结果）；90.子集II（子集问题+去重）
weixin_47284299的博客
11-25 832
算法训练Day28 | LeetCode93.复原IP地址（回溯算法中的切割问题2）；78 子集（每个节点都收集结果）；90.子集II（子集问题+去重）
leetcode答案-One-Day-One-LeetCode:记录每次练习LeetCode的答案
06-30
LeetCode是一个广受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。这个压缩包“One-Day-One-LeetCode”似乎是一个个人项目，记录了作者每天解决LeetCode问题的答案。通过结合使用Mocha作为测试...
算法训练 Day41 | 动态规划训练Day3；LeetCode343. 整数拆分；LeetCode96. 不同的二叉搜索树
weixin_47284299的博客
10-31 528
算法训练 Day41 | 动态规划训练Day3；LeetCode343. 整数拆分；LeetCode96. 不同的二叉搜索树
DAY 22冲击蓝桥杯——Python数据结构与算法04 数组leetcode练习
f1220684378的博客
02-16 192
文章目录leetcode 485leetcode 283leetcode 27 leetcode 485 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。 class Solution: def findMaxConsecutiveOnes(self, nums: List[int]) -> int: count=0 result=0 for i in nums: if i==1:
算法基础-链表
August的专栏
11-05 227
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 335
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 322
Leetcode 160. 相交链表
二叉树(一)
m0_74340589的博客
11-05 447
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 737
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1540
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值