递归与回溯

最新推荐文章于 2024-09-26 10:11:15 发布
最新推荐文章于 2024-09-26 10:11:15 发布
阅读量120 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： leetcode 数据结构 剪枝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44222272/article/details/106924214
版权

递归与回溯

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

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

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

LeetCode 131

    class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> result=new ArrayList<>();
        DFS(result,s,new ArrayList<String>());
        return result;   
    }
    public void DFS(List<List<String>> result,String s,List<String> temp){
        if(s.length()==0){
            //每次需要新new一个ArrayList 把temp赋值过去
            //不能直接使用temp temp还会因为回溯动态变化
            result.add(new ArrayList<String>(temp));
            return;
        }
        for(int i=1;i<=s.length();i++){
            if(isPalindrome(s.substring(0,i))){
                temp.add(s.substring(0,i));
                DFS(result,s.substring(i,s.length()),temp);
                //回溯
                temp.remove(temp.size()-1);
            }
        }
    }
    public boolean isPalindrome(String s){
       for(int l=0,r=s.length()-1;l<r;l++,r--){
           if(s.charAt(l)!=s.charAt(r)){
               return false;
           }
       }
       return true;
    }
}

  • 给定一个 没有重复 数字的序列，返回其所有可能的全排列。

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

leetcode -- 46

    class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        boolean[] used=new boolean[nums.length];
        return DFS(result,nums,used,new ArrayList<>());
    }
    public List<List<Integer>> DFS(List<List<Integer>> result,int[] nums,boolean[] used,List<Integer> temp){
        //表明temp添加完了所有数 递归出口
        if(temp.size()==nums.length){
            result.add(new ArrayList<>(temp));
            return result;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]!=true){
                //temp在动态保存添加过程中的结果值
                temp.add(nums[i]);
                used[i]=true;
                DFS(result,nums,used,temp);
                used[i]=false;
                temp.remove(temp.size()-1);
            }
        }
        return result;
    }
}

  • 给定一个可包含重复数字的序列，返回所有不重复的全排列。

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

leetcode - 47

    class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        //排序
        Arrays.sort(nums);
        List<List<Integer>> result=new ArrayList<>();
        boolean[] used=new boolean[nums.length];
        return DFS(result,nums,used,new ArrayList<>());
    }
    public List<List<Integer>> DFS(List<List<Integer>> result,int[] nums,boolean[] used,List<Integer> temp){
        if(temp.size()==nums.length){
            result.add(new ArrayList<>(temp));
            return result;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]!=true){
                //剪枝
                //注意used[i-1]==false 表示nums[i-1]刚刚被撤销 这种就需要剪枝
                //如果used[i-1]!=false 表示nums[i]在正常添加过程中 如果剪枝反而错误
                if(i>0&&nums[i]==nums[i-1]&&!used[i-1])
                    continue;
                temp.add(nums[i]);
                used[i]=true;
                DFS(result,nums,used,temp);
                used[i]=false;
                temp.remove(temp.size()-1);
            }
        }
        return result;
    }
}

  • 给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

输入: n = 4, k = 2
 输出:
 [
   [2,4],
   [3,4],
   [2,3],
   [1,2],
   [1,3],
   [1,4],
 ]
 
 leetcode -77

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result=new ArrayList<>();
        int[] nums=new int[n];
        for(int i=0;i<n;i++){
            nums[i]=i+1;
        }
        return DFS(result,k,new ArrayList<Integer>(),0,nums);
    }
    public List<List<Integer>> DFS(List<List<Integer>>  result,int k,ArrayList<Integer> temp,int index,int[] nums){
        if(temp.size()==k){
            result.add(new ArrayList(temp));
            return result;
        }
        for(int i=index;i<nums.length;i++){
                temp.add(nums[i]);
            	//这里下一次DFS的时候 index赋值为i+1 保证已经选出的元素不在出现
                DFS(result,k,temp,i+1,nums);   
                temp.remove(temp.size()-1);
        }
        return result;
    }
}

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

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

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

（LeetCode -- 39）

    class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<>();
        return DFS(candidates,result,new ArrayList<Integer>(),target,0);
    }
    public List<List<Integer>> DFS(int[] candidates,List<List<Integer>> result,List<Integer> temp,int target,int start){
        
        if(target<0)
            return result;

        if(target==0){
            result.add(new ArrayList<>(temp));
            return result;
        }
        
        //对于解集不能包含重复的组合问题 循环从start开始 保证解集中没有重复
        for(int i=start;i<candidates.length;i++){
            temp.add(candidates[i]);
            //这里下一次DFS的start赋值为i 是因为解中可以出现2 2 2 。。这样重复元素的情况
            DFS(candidates,result,temp,target-candidates[i],i);
            temp.remove(temp.size()-1);
        }
        return result;
    }
}

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

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

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

（LeetCode --40）

    class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //先排序
        Arrays.sort(candidates);
        List<List<Integer>> result=new ArrayList<>();
        boolean[] used=new boolean[candidates.length];
        return DFS(candidates,result,new ArrayList<Integer>(),target,used,0);
    }
    public List<List<Integer>> DFS(int[] candidates,List<List<Integer>> result,List<Integer> temp,int target,boolean[] used,int start){
        if(target<0)
            return result;

        if(target==0){
            result.add(new ArrayList<>(temp));
            return result;
        }
		//定义start索引 解决解集不能包含重复的组合
        for(int i=start;i<candidates.length;i++){
            if(!used[i]){
                //剪枝 给定的样例中包含重复元素 为了解集不能包含重复的组合 剪枝
                if(i>0&&candidates[i]==candidates[i-1]&&!used[i-1])
                   continue;               
                temp.add(candidates[i]);
                used[i]=true;
                DFS(candidates,result,temp,target-candidates[i],used,i+1);
                used[i]=false;
                temp.remove(temp.size()-1);
            }
        }
        return result;
    }
}

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

    说明：

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

​```xml
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
​```

leetcode 216

    class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> result=new ArrayList<>();
        int[] nums=new int[9];
        for(int i=0;i<9;i++){
            nums[i]=i+1;
        }
        return DFS(result,nums,new ArrayList<>(),n,k,0);
    }
    public List<List<Integer>> DFS(List<List<Integer>> result,int[] nums,List<Integer> temp,int n,int k,int start){
        if(n<0){
            return result;
        }

        //递归终止条件有2个  temp的大小为3 且这3个数和为给定的值
        if(temp.size()==k&&n==0){
            result.add(new ArrayList<>(temp));
            return result;
        }

        //解集不能包含重复的组合问题 从start开始循环 不每次从0开始
        for(int i=start;i<nums.length;i++){
            temp.add(nums[i]);
            DFS(result,nums,temp,n-nums[i],k,i+1);
            temp.remove(temp.size()-1);
        }
        return result;
    }
}

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

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

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

来源：力扣（LeetCode--78）

    class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        //对元素个数k做一次循环 这个k对应了DFS时候的终止条件
        for(int k=0;k<=nums.length;k++){
            DFS(result,new ArrayList<>(),k,nums,0);
        }
        return result;
    }
    public void  DFS(List<List<Integer>> result,List<Integer> temp,int k,int[] nums,int start){
        if(temp.size()==k){
            result.add(new ArrayList<>(temp));
            return;
        }
        for(int i=start;i<nums.length;i++){
            temp.add(nums[i]);
            DFS(result,temp,k,nums,i+1);
            temp.remove(temp.size()-1);
        }
        return;
    }
}

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

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

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

leetcode -90

    class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> result=new ArrayList<>();
        boolean[] flags=new boolean[nums.length];
        for(int k=0;k<=nums.length;k++){
            DFS(result,new ArrayList<>(),k,nums,0,flags);
        }
        return result;
    }
     public void  DFS(List<List<Integer>> result,List<Integer> temp,int k,int[] nums,int start,boolean[] flags){
        if(temp.size()==k){
            result.add(new ArrayList<>(temp));
            return;
        }
        for(int i=start;i<nums.length;i++){
            if(!flags[i]){
                //给定输入样例中包含重复元素 就要先排序 后剪枝
                if(i>0&&nums[i]==nums[i-1]&&!flags[i-1])
                        continue;
                    temp.add(nums[i]);
                    flags[i]=true;
                    DFS(result,temp,k,nums,i+1,flags);
                    flags[i]=false;
                    temp.remove(temp.size()-1);
                
            }
        }
        return;
     }
}
zyk1.
关注
专栏目录
LeetCode-Generate Parentheses
weixin_34143774的博客
07-27 87
Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses. For example, given n = 3, a solution set is: [ "((()))", "(()())", "(())()", ...
递归与回溯问题
GUI1259802368的博客
07-30 1505
1. 题目描述：输入两个整数 n 和 m，从数列1，2，3.......n 中随意取几个数,使其和等于 m ,要求将其中所有的可能组合列出来输入描述：每个测试输入包含2个整数,n和m输出描述：按每个组合的字典序排列输出,每行输出一种组合 示例1 输入 5 5 输出 1 4 2 3 5 解答 #include&lt;iostream&gt; #include&lt;vector&gt; usin...
回溯算法
CleverCode的博客
08-29 2770
1 算法原理 回溯法有通用解法的美称，对于很多问题，如迷宫等都有很好的效果。回溯算法实际上一个类似枚举的深度优先搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回（也就是递归返回），尝试别的路径。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。回溯法说白了就是穷举法。回溯法一般用递归来解决。 2 算法流程图 过程： 1 ...
Java数据结构与算法——递归与回溯
★★光亭★★
03-16 6895
Java数据结构与算法——递归与回溯
算法-递归与回溯
yym1413的博客
11-22 772
算法-递归与回溯
递归与回溯法
yy的博客
07-02 285
先看大家都熟悉的一个民间故事：从前有座山，山上有座庙，庙里有一个老和尚在给小和尚讲故事，故事里说，从前有座山，山上有座庙，庙里有一个老和尚在给小和尚讲故事，故事里说……。象这样，一个对象部分地由它自己组成，或者是按它自己定义，我们称之为递归。一个函数、过程、概念或数学结构，如果在其定义或说明内部又直接或间接地出现有其本身的引用，则称它们是递归的或者是递归定义的。在程序设计中，过程或函数直接或者间接调用自己，就被称为递归调用。
递归与回溯4：一文彻底理解回溯
纵横千里 捭阖四方 的专栏
01-13 5680
1.回溯大白话 关于回溯，先用大白话说几个结论： 1.回溯能干什么？ 主要解决那些暴力枚举也无法解决的问题。 2.回溯与递归是什么关系？ 回溯是递归的纵横拓展，主要是递归（纵）+局部暴力枚举（横）。所以你可以从递归和暴力两个方面来拆解回溯问题。 3.回溯的关键在于“回”上，也就是要撤销，为什么要撤销？ 因为回溯本质上仍然是枚举，你不喜欢她的前任，你要将她前任的所有东西都仍然，然后才愿意重新开始！ 4.回溯经常看到“剪枝”，什么是剪枝，为什么要剪枝？ 剪枝就是去掉那些不必要的递归，从而提高执
Java实现递归与回溯算法详解及图解
qq_40254606的博客
07-19 1659
递归（Recursion）和回溯（Backtracking）是算法设计中的两个重要概念。递归通过函数调用自身来解决问题，而回溯是一种通过试探性的解决问题的方法，适用于组合问题和路径问题。本文将详细讲解递归与回溯的基本原理，并结合图解和实例代码，帮助您全面理解这些高级算法。递归是一种通过函数调用自身来解决问题的方法。一个递归函数通常包含两个部分：优点：缺点：阶乘是一个非常经典的递归问题。阶乘表示一个正整数的所有整数乘积，记作 (n!)。例如，5的阶乘记作 (5! = 54 3* 2 * 1 = 120)。以下
递归与回溯的区别
⭐君子以自强不息
02-07 913
递归 程序调用自身的编程技巧称为递归（ recursion）。 为了描述问题的某一状态，必须用到该状态的上一个状态；而如果要描述上一个状态，又必须用到上一个状态的上一个状态…… 这样用自己来定义自己的方法就是递归。 递归生成斐波那契数列 fibonacci(n): // n 表示求数列中第 n 个位置上的数的值 if n == 1: // 设置结束递归的限制条件 return 1 if n == 2: // 设置结束递归
基于Python数据结构之递归与回溯搜索
09-17
### 基于Python数据结构之递归与回溯搜索 #### 1. 递归函数与回溯深搜的基础知识 **递归**是一种重要的编程思想和技术，它指的是一个函数在其定义或实现中直接或间接地调用自身。递归函数通常用于解决可以分解为...
C语言递归与回溯.md
08-14
### C语言递归与回溯知识点详解 #### 1. 递归的原理与应用 ##### 1.1 递归的基本概念 递归是一种重要的编程技术，它允许一个函数直接或间接地调用自身来解决问题。递归的核心思想是将大问题分解为小问题，这些小...
javascript-leetcode面试题解递归与回溯问题之第59题递归矩阵-题解.zip
03-15
本题解主要关注的是LeetCode中的第59题，这是一个关于递归与回溯策略的问题，特别是在解决矩阵问题上的应用。递归和回溯是计算机科学中解决问题的两种常用方法，它们在处理复杂逻辑和搜索问题时尤其有效。 递归是一...
javascript-leetcode面试题解递归与回溯问题之第1291题顺次数-题解.zip
03-15
本压缩包文件“javascript_leetcode面试题解递归与回溯问题之第1291题顺次数_题解.zip”显然包含了对LeetCode第1291题的解答，重点讨论了递归和回溯这两种编程技巧。 递归是编程中一种强大的技术，它是指一个函数或...
力扣30. 串联所有单词的子串
最新发布
dastatham的博客
09-26 415
给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。 s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。
2024/9/21 leetcode 21.合并两个有序链表 2.两数相加
su_xu_chao的博客
09-21 1224
将两个升序链表合并为一个新的链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。[][0]l2。
C++速通LeetCode中等第25题-验证二叉搜索树（中序遍历堆栈迭代法）
lyx的博客
09-23 205
中序遍历堆栈迭代法
[leetcode]113_路径总和II_输出所有路径
weixin_45653183的博客
09-24 349
leetcode 的 Python 代码——处理输入输出；仅记录便于以后自查自学使用
递归与回溯算法详解
"递归与回溯法是算法思想中的重要概念，常用于解决复杂问题。递归是指一个函数或过程在其定义中直接或间接调用自身，形成一种自相似的解决问题方式。递归过程通常包含递推和回归两个阶段，前者是问题的深入，后者是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值