算法-回溯-20230508

最新推荐文章于 2024-07-17 20:43:45 发布
最新推荐文章于 2024-07-17 20:43:45 发布
阅读量38 收藏
点赞数
文章标签： 算法 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35286594/article/details/130558164
版权

回溯模板

private void backTracking(参数) {
        if (终止条件) {
            保存结果等处理
            return;
        }
        for (int i = start; i <= end; i++) { // 循环
            list.add(i); // 增加参数
            backTracking(参数);
            list.remove(list.size() - 1); // 回溯之后弹出
        }
    }

1.组合

class Solution {
   public List<List<Integer>> combine(int n, int k) {
       // 回溯
        List<List<Integer>> result = new ArrayList<>();
        backTracking(new ArrayList<>(), 1, n, k, result);
        return result;
    }
    private void backTracking(List<Integer> list, int start, int end, int k, List<List<Integer>> result ) {
        if (list.size() == k) {
            result.add(new ArrayList<>(list));
            return;
        }
        for (int i = start; i <= end; i++) {
            list.add(i);
            backTracking(list, i+1, end, k, result);
            list.remove(list.size() - 1);
        }
    }
}

2. 组合总和

class Solution {
    private List<List<Integer>> resultList = new ArrayList<>();
    private int sum = 0;
    private LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backTracking(1,k,n);
        return resultList;
    }

    private void backTracking(int start, int k, int n) {
        if (sum > n || path.size() > k) {
            return;
        }
        if (sum ==n && path.size() == k) {
            resultList.add(new ArrayList<>(path));
            return;
        }
        for (int i = start;  i< 10-(k-path.size()) +1; i++) {
            sum += i;
            path.add(i);
            backTracking(i+1, k, n);
            path.removeLast();
            sum-=i;
        }
    }
}

3.电话号组合

class Solution {
     private List<String> result = new ArrayList<>();
    private StringBuilder stringBuilder = new StringBuilder();
    private Map<Character, String[]> keyDigitsMap = new HashMap<>();
    {
        keyDigitsMap.put('2', new String[]{"a", "b", "c"});
        keyDigitsMap.put('3', new String[]{"d", "e", "f"});
        keyDigitsMap.put('4', new String[]{"g", "h", "i"});
        keyDigitsMap.put('5', new String[]{"j", "k", "l"});
        keyDigitsMap.put('6', new String[]{"m", "n", "o"});
        keyDigitsMap.put('7', new String[]{"p", "q", "r", "s"});
        keyDigitsMap.put('8', new String[]{"t", "u", "v"});
        keyDigitsMap.put('9', new String[]{"w", "x", "y", "z"});
    }

    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() <=0) {
            return result;
        }
        backTracing(digits, 0);
        return result;
    }

    private void backTracing(String digits, int start) {
       if (stringBuilder.length() == digits.length()) {
            result.add(stringBuilder.toString());
            return;
        }
          String[] strings = keyDigitsMap.get(digits.charAt(start));
            for (int j = 0; j < strings.length; j++) {
                stringBuilder.append(strings[j]);
                backTracing(digits, start + 1);
                stringBuilder.deleteCharAt(stringBuilder.length()-1);
            }
    }
}

4. 组合之和，字段无限使用

回溯一定是一进一出的

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

    private void backTracking(int[] candidates, int index, int target) {
        if (sum == target) {
            result.add(new ArrayList<>(list));
            return;
        }
        if (sum > target) {
            return;
        }
        for (int i = index; i< candidates.length; i++) {
            sum += candidates[i];
            list.add(candidates[i]);
            if (sum < target){
                backTracking(candidates, i, target);
            }else {
                backTracking(candidates, i + 1, target);
            }
            Integer integer = list.removeLast();
            sum -= integer;
        }
    }
}

5. 组合总和2，结果集不能有重复数组

usesd数组，得好好理解

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();
    private int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        boolean[] used = new boolean[candidates.length];
        backTracking(candidates, target, 0, used);
        return result;
    }

    private void backTracking(int[] candidates, int target, int start, boolean[] used) {
        if (sum == target) {
            result.add(new ArrayList<>(list));
            return;
        }

        for (int i = start; i< candidates.length && sum + candidates[i] <= target; i++) {
            if ( i >0 && !used[i - 1] && candidates[i-1] == candidates[i]) {
                continue;
            }
            sum += candidates[i];
            list.add(candidates[i]);
            used[i] = true;
            backTracking(candidates, target, i + 1, used);
            used[i] = false;
            sum -= candidates[i];
            list.removeLast();
        }
    }
}

6. 切割字符串， === 组合

看了半天，真复杂

class Solution {
    List<List<String>> result = new ArrayList<>();
    LinkedList<String> lists = new LinkedList<>();
    public List<List<String>> partition(String s) {
        backTracking (s,  0);
        return result;
    }

    private void backTracking(String s, int start) {
        if (start == s.length()) {
            result.add(new ArrayList<>(lists));
            return;
        }

        for (int i =start; i < s.length(); i++) {
            if (!checkPalindrome(s, start, i+1)) {
                continue;
            }
            lists.add(s.substring(start, i + 1));
            backTracking(s, i + 1);
            lists.removeLast();
        }
    }

    private boolean checkPalindrome(String s, int start, int i) {
        i = i -1;
        while (start < i) {
            if (s.charAt(start) == s.charAt(i)) {
                start++;
                i --;
            }else {
                return false;
            }
        }
        return true;
    }
}

7. 切割ip

缝缝补补

class Solution {
     private List<String> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();

    public List<String> restoreIpAddresses(String s) {
        // 切割，4位数
        backTracking(s, 0);
        return result;
    }

    private void backTracking(String s, int start) {
        if (list.size() > 4) {
            return;
        }
        if (start >= s.length()) {
            if (list.size() == 4) {
                result.add(list.stream().map(String::valueOf).collect(Collectors.joining(".")));
            }
            return;
        }
        for (int i = start; i< s.length(); i++) {
            if (i - start > 3 || s.charAt(start) == '0' && i > start) {
                break;
            }
            if ( 255>=Integer.valueOf(s.substring(start, i+1)) && 0 <= Integer.valueOf(s.substring(start, i+1))) {
                list.add(Integer.valueOf(s.substring(start, i+1)));
            }else {
                continue;
            }
            backTracking(s, i + 1);
            list.removeLast();
        }

    }
}

8.数组的子数组

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums, 0);
        return result;
    }

    private void backTracking(int[] nums, int start) {
        result.add(new ArrayList<>(list));
        for (int i =start; i< nums.length; i++) {
            list.add(nums[i]);
            backTracking(nums, i+1);
            list.removeLast();
        }
    }
    
}

9. 数组的子数组，不能重复，层级去重

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backTracking(nums, 0, used);
        return result;
    }

    private void backTracking(int[] nums, int start, boolean[] used) {
        
        result.add(new ArrayList<>(list));

        for (int i =start; i< nums.length; i++) {
            if (i > 0 && nums[i] == nums[i-1] && !used[i - 1] ) {
                continue;
            }
            list.add(nums[i]);
            used[i] = true;
            backTracking(nums, i+1, used);
            used[i] = false;
            list.removeLast();
        }
    }
}

10.数组的递增子数组

剪枝！！！，同父节点下不重复

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return result;
    }

    private void backTracking(int[] nums, int start) {
        if (list.size() > 1) {
            result.add(new ArrayList<>(list));
        }
        int [] used = new int[201];
        for (int i = start; i < nums.length;i++) {
            if (!list.isEmpty() && nums[i] < list.getLast()) {
                continue;
            }
            if (used[nums[i] + 100] == 1) {
                continue;
            }
            list.add(nums[i]);
            used[nums[i]+100] = 1;
            backTracking(nums, i +1);
            list.removeLast();
        }
    }
}

11. 全排列

每次都从0开始遍历，单树每个元素使用一次。

private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();

    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backTracking(nums, used);
        return result;
    }

    private void backTracking(int[] nums,  boolean[] used) {
        if (list.size() == nums.length) {
            result.add(new ArrayList<>(list));
            return;
        }
        for (int j = 0; j < nums.length; j++) {
            if (used[j]) {
                continue;
            }
            list.add(nums[j]);
            used[j] = true;
            backTracking(nums, used);
            list.removeLast();
            used[j] = false;
        }
    }

12.全排列2，返回不重复的

去重啊，剪枝啊。同层值相同的，并且前一个节点使用过，则剪枝

class Solution {

    private List<List<Integer>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();

    public List<List<Integer>> permute(int[] nums) {

        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backTracking(nums, used);
        return result;
    }

    private void backTracking(int[] nums, boolean[] used) {
        if (list.size() == nums.length) {
            result.add(new ArrayList<>(list));
        }
        for (int i = 0; i< nums.length; i++) {
            if(used[i]) {
                continue;
            }
            if(i > 0 && !used[i-1] && nums[i] == nums[i-1]) {
                continue;
            }
            list.add(nums[i]);
            used[i] = true;
            backTracking(nums, used);
            list.removeLast();
            used[i] = false;
        }
    }
}

13. n皇后，回溯，手写

class Solution {
    private List<List<String>> result = new ArrayList<>();
    private LinkedList<Integer> list = new LinkedList<>();
    public List<List<String>> solveNQueens(int n) {

        backTracking(n);
        return result;
    }

    private void backTracking(int n) {
        if (list.size() == n ) {
            result.add(getResult(list));
            return;
        }
        for (int i =0 ; i < n; i ++) {
            // 竖
            if (list.contains(i)) {
                continue;
            }
            // 斜对角
            if (!list.isEmpty()) {
                int size = list.size();
                boolean flag = false;
                for (int j = 0; j < list.size(); j++) {
                    if (size -j == i - list.get(j) ||
                        size -j == list.get(j) - i) {
                        flag = true;
                        break;
                    }
                }
                if (flag) {
                    continue;
                }
            }
            list.add(i);
            backTracking(n);
            list.removeLast();
        }
    }

    private List<String> getResult(LinkedList<Integer> list) {
        int size = list.size();
        return list.stream().map(e -> {
            StringBuilder sb = new StringBuilder();
            int i = 0;
            while (i < size) {
                if (i == e) {
                    sb.append("Q");
                }else
                sb.append(".");
                i++;
            }
            return sb.toString();
        }).collect(Collectors.toList());

    }
}

丘很stao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java-算法-回溯＜一＞
weixin_45532984的博客
06-04 3908
回溯算法是基于递归函数之上的，本质是穷举所有可能符合答案的选项。和一般递归最大的区别是，本身带有撤销这一明显特征，即选择，递归，然后返回，撤销。虽然可以加一些剪枝的操作，但本身算法时间复杂度很高，没有改变穷举的本质。回溯算法主要解决排列，组合，子集类的问题 。.........
算法-回溯算法
L_world_的博客
03-09 7943
思路： 解决⼀个回溯问题，实际上就是⼀个决策树的遍历过程。需要思考3 个问题： 路径：也就是已经做出的选择。 选择列表：也就是你当前可以做的选择。 结束条件：也就是到达决策树底层，⽆法再做选择的条件。 框架： result = [] def backtrack(路径, 选择列表): if 满⾜结束条件: result.add(路径) return for 选择 in 选择列表: 做选择 backtrack(路径, 选择列表) 撤销选择 Leetcode 46. 全排列 c
算法-----回溯算法
2301_77599154的博客
12-10 1494
回溯算法（Backtracking Algorithm）是一种用于解决组合优化问题的算法，它通过逐步构建候选解并进行验证，以寻找所有满足特定条件的解。回溯算法通常应用于在给定约束条件下枚举所有可能解的问题，如组合、排列、子集等。回溯算法的基本思想是通过递归的方式进行搜索，每一步都尝试扩展当前的解，直到找到满足条件的解或者确定无解。在搜索的过程中，如果当前的解不满足约束条件，就会回溯到上一步进行其他选择，继续搜索。定义问题的解空间，确定问题的约束条件。
js---回溯算法
weixin_43502666的博客
02-24 531
在 JavaScript 中实现回溯算法通常需要使用递归来进行搜索。回溯算法通常用于解决组合优化问题、排列组合问题、棋盘类游戏等。回溯算法一般是一个for加递归,for循环横向遍历,递归纵向遍历—以上是回溯算法的基本框架 1、回溯算法求数组所有子集 2、回溯算法求全排列
基本算法-回溯法（迷宫问题）
热门推荐
翟天保的博客
04-22 2万+
本文介绍一种经典算法——回溯法，以下是本篇文章正文内容，包括算法简介、算法流程和C++代码实现。
算法分析-回溯算法-求解N皇后问题
xionghui2007的博客
12-28 1307
算法分析，回溯算法，求解N皇后问题
【算法-回溯法】N皇后问题
@point
10-13 3366
回溯法 N皇后问题
算法-回溯法
10-15 3297
回溯法就是一种有组织的系统化搜索技术，可以看作是蛮力法穷举搜索的改进。 回溯法每次只构造可能解的一部分，然后评估这个部分解，如果这个部分解有可能导致一个完整解，则对其进一步构造，否则，就不必继续构造这个部分解了。回溯法常常可以避免搜索所有的可能解，所以，它适用于求解组合数量较大的问题。 概述 问题的解空间 复杂问题常常有很多的可能解，这些可能解构成了问题的解空间。解空间也就是进行穷举的搜索空间，所以，解空间中应该包括所有的可能解。 为了用回溯法求解一个具有n个输入的问题，一般情况下，将其可能解表示为满足某个
算法-回溯
sinat_31655507的博客
03-18 279
Backtracking
秋招-算法-回溯算法篇
qq_50665031的博客
07-31 1075
​回溯实际上是一种试探算法，这种算法跟暴力搜索最大的不同在于，在回溯算法里，是一步一步地小心翼翼地进行向前试探，会对每一步探测到的情况进行评估，如果当前的情况已经无法满足要求，那么就没有必要继续进行下去，也就是说，它可以帮助我们避免走很多的弯路。​回溯算法的特点在于，当出现非法的情况时，算法可以回退到之前的情景，可以是返回一步，有时候甚至可以返回多步，然后再去尝试别的路径和办法。这也就意味着，想要采用回溯算法，就必须保证，每次都有多种尝试的可能。...
数据结构与算法-回溯算法
06-13
回溯算法是一种通过逐步试探并回溯来寻找问题解集的算法。它广泛应用于组合问题、切割问题、子集问题、全排列问题和棋盘问题等领域。其核心思想是在当前情况下无解时，返回到上一层继续试探其他情况，直到找到解或...
贪婪算法-回溯-深度优先搜索.pdf
05-16
《贪婪算法、回溯法与深度优先搜索》 贪婪算法，顾名思义，是一种求解问题时采取贪心策略的算法。在面对问题时，它总是做出当前看起来最优的选择，而不是全局最优。贪婪算法通常用于解决部分最优问题，虽然不能保证...
15-搜索算法---回溯.ppt
05-24
15-搜索算法---回溯.ppt
贪婪算法-回溯-深度优先搜索.docx
05-27
回溯法是一种试探性的搜索算法，用于解决那些可能有多个解或无解的问题。它通过深度优先搜索解空间树，从初始状态开始，逐步尝试所有可能的路径。在遇到无法继续的情况时，回溯法会撤销最近的决策，尝试其他可能的...
北京工业大学--算法作业4--回溯算法--任务分配--Java
12-12
北京工业大学--算法作业4--回溯算法--任务分配--Java 有n份作业分配给n个人去完成，每人完成一份作业。假定第i个人完成第j份作业需要花费cij时间， cij>0,1≦i,j≦n。试设计一个回溯算法，将n份作业分配给n个人完成...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 193
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 429
算法014：找到字符串中所有字母异位词
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
最新发布
qq_44962949的博客
07-17 92
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 207
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
回溯算法--装载问题
12-01
回溯算法是一种解决问题的算法思想，它通过不断地尝试所有可能的解决方案来寻找问题的最优解。而装载问题是回溯算法的一个经典应用，它是指在给定一些集装箱和一艘载重量为C的轮船的情况下，如何将这些集装箱装载到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值