回溯算法

最新推荐文章于 2023-08-07 16:55:10 发布
最新推荐文章于 2023-08-07 16:55:10 发布
阅读量160 收藏
点赞数
分类专栏： leetcode 文章标签： java 递归算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dtzly/article/details/111030973
版权

39. 组合总和

思路： 题意是给 定 一 个 无 重 复 元 素 的 数 组 candidates 和 一 个 目 标 数 target ， 找 出 candidates 中所有可以使数字和为 target 的组合。注意一点数组里的元素可以无限次取。做法是以当前数组中的元素往后dfs。

class Solution {
    private void dfs(List<List<Integer>> res,List<Integer>tmp,int []a, int target, int cur){
        if(target==0) {res.add(new ArrayList<>(tmp)); return;}
        for(int i=cur; i<a.length ; i++){
            if(a[i]>target) continue;
            tmp.add(a[i]);
            dfs(res,tmp,a,target-a[i],i);
            tmp.remove(tmp.size()-1);
        }
    }
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(res,new ArrayList<Integer>(),candidates,target,0);
        return res;
    }
}

40. 组合总和 II

题意：数组里的元素只能读一次。解题思想还是一样的，我们要做的是怎么过滤掉重复的，首 先 可 以 对 原 数 组 进 行 排 序 ， 排 序 之 后 相 同 的 肯 定 是 挨 着 的 ， if （ candidates [i] == candidates [i - 1] ） 我 们 就 过 滤 掉 candidates [i] 。
代码：

class Solution {
    private void dfs(List<List<Integer>> res,List<Integer> tmp, int a[], int target,int cur){
        if(target==0){res.add(new ArrayList<Integer>(tmp)); return;}
        for(int i=cur;i<a.length;i++){
            if(target<a[i]) continue;
            if(i>cur&&a[i]==a[i-1]) continue;
            tmp.add(a[i]);
            dfs(res,tmp,a,target-a[i],i+1);
            tmp.remove(tmp.size()-1);
        }
    }
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> res = new ArrayList<>();
        dfs(res,new ArrayList<>(),candidates,target,0);
        return res;
    }
}

216. 组合总和 III

思路：题意是给定[k,n], 从1-9中选出k个数字，他们的和等于n。做法是枚举1-9的数字进行深搜。这里要注意JAVA的深拷贝和浅拷贝。
代码：

class Solution {
    private void dfs(List<List<Integer>> res, List<Integer> tmp, int cur, int n, int k){
       //如果候选数字的个数达到k并且和是n(n每次遇到新元素减去直到为0)
        if(tmp.size()==k) {
            if(n==0) {res.add(new ArrayList<>(tmp));}
            return;
        }
        //每次tmp添加当前元素，然后回溯，remove掉队尾元素
        for(int i=cur;i<=9;i++){
            tmp.add(i);
            dfs(res,tmp,i+1,n-i,k);
            tmp.remove(tmp.size()-1);
        }
    }
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> res = new ArrayList<>();
        //从1开始枚举，1-9 接着2-9 接着3-9 。。。
        dfs(res,new ArrayList<>(),1,n,k);
        return res;
    }
}

进一步思考：如果1-9数字可以重复呢？ 其实只需要在递归中i+1 -->i

面试题 08.12. 八皇后

思路：输入n 代表n*n的棋盘，求摆置皇后个所有可能性。
代码：

class Solution {
    public List<List<String>> solveNQueens(int n) {
      //初始化棋盘
        char[][] chess = new char[n][n];
        for(int i=0; i<n;i++){
            for(int j=0; j<n; j++){
                chess[i][j] = '.';
            }
        }
    //因为leetcode输出是List<List<String>>结构，而棋盘我们设置的是二维char数组，因此需要把结果进行转换
        List<List<String>> res = new ArrayList<>();
        solve(res,chess,0);
        return res;
    }
    //根据每行进行递归，如果当前行数等于棋盘长度则递归终止。每次按列进行回溯探测。
    private void solve(List<List<String>> res, char[][] chess,int row){
        if(row == chess.length) {res.add(array2List(chess));return;}
        for(int col=0;col<chess[0].length;col++){
            if(valid(chess,row,col)){
                chess[row][col] = 'Q';
                solve(res,chess,row+1);
                chess[row][col] = '.';
            }
        }
    }
    //检查当前落下棋子位置的正确性，即上面，左上，右上是否已经存在Queue
    private boolean valid(char[][]chess,int row, int col){
        //up
        for(int i=0;i<row;i++){if(chess[i][col]=='Q') return false;}
        //up-right
        for(int i=row-1,j=col+1;i>=0&&j<chess[0].length;i--,j++){if(chess[i][j]=='Q') return false;}
        //up-left
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){if(chess[i][j]=='Q') return false;}
        return true;
    }
    List<String>array2List(char[][]chess){
        List<String> target = new ArrayList<>();
        for(int i=0;i<chess.length;i++){target.add(new String(chess[i]));}
        return target;
    }
}
  • 测试下假如就使用List<char[][]>
class Solution {
     private boolean valid(char[][]chess,int row, int col){
        //up
        for(int i=0;i<row;i++){if(chess[i][col]=='Q') return false;}
        //up-right
        for(int i=row-1,j=col+1;i>=0&&j<chess[0].length;i--,j++){if(chess[i][j]=='Q') return false;}
        //up-left
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){if(chess[i][j]=='Q') return false;}
        return true;
    }
    private void solve(char[][] chess, List<char[][]>res, int row){
        if(row==chess.length) {
            char[][]tmp = new char[chess.length][chess[0].length];
            for(int i=0;i<chess.length;i++){
                for(int j=0;j<chess[0].length;j++){
                    tmp[i][j] = chess[i][j];
                }
            }
            res.add(tmp);
        }
        for(int col=0;col<chess[0].length;col++){
            if(valid(chess,row,col)){
                chess[row][col] = 'Q';
                solve(chess,res,row+1);
                chess[row][col] = '.';
            }
        }
    }
     public List<List<String>> solveNQueens(int n) {
         List<List<String>> res = new ArrayList<>();
         solveNQueens1(n);
         return res;
     }
    public List<char[][]> solveNQueens1(int n) {
        char[][] chess = new char[n][n];
        List<char[][]> res = new ArrayList<>();
        for(int i=0; i<n;i++){
            for(int j=0; j<n; j++){
                chess[i][j] = '.';
            }
        }
        solve(chess,res,0);
        for(char[][] each: res){
            for(int i=0;i<each.length;i++){
                for(int j=0;j<each[0].length;j++){
                    System.out.print(each[i][j]+" ");
                }
                System.out.println();
            }
            System.out.println("==========");
        }
        return res;
    }
}

46. 全排列

思路：题意是要求一组没有重复数字的全排列。在回溯的时候判断下tmp里面是否包含之前的数字即可。
代码：

class Solution {
    private void dfs(List<List<Integer>> res, List<Integer> tmp, int []nums){
        if(tmp.size()==nums.length){res.add(new ArrayList<>(tmp)); return;}
        for(int i=0;i<nums.length;i++){
            if(tmp.contains(nums[i])==false){
                tmp.add(nums[i]);
                dfs(res,tmp,nums);
                tmp.remove(tmp.size()-1);
            }
        }
    }
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(res,new ArrayList<>(),nums);
        return res;
    }
}

78. 子集

思路：求一组整数数组的子集。

class Solution {
    private void dfs(List<List<Integer>> res,List<Integer> tmp,int[]nums,int cur){
        res.add(new ArrayList<>(tmp));
        for(int i=cur;i<nums.length;i++){
            tmp.add(nums[i]);
            dfs(res,tmp,nums,i+1);
            tmp.remove(tmp.size()-1);
        }
    }
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(res,new ArrayList<>(),nums,0);
        return res;
    }
}

1219. 黄金矿工

思路：题意是n*m的金矿，值为0不可开采。工人可以从任意单元格进入从上下左右四个方向进行开采。 遍历这个二维数组，从每个单元格出发深搜找出从该点出发的最大值。
代码：

class Solution {
    private int dfs(int x, int y,int [][]grid){
        if(x<0||x>=grid.length||y<0||y>=grid[0].length||grid[x][y]==0) return 0;
        //从该点出发深度搜索，为了防止重复搜索该点的值先置为0，dfs后再还原
        int tmp = grid[x][y];
        int max = Integer.MIN_VALUE;
        grid[x][y] = 0;
        int up = dfs(x,y-1,grid);
        int down = dfs(x,y+1,grid);
        int left = dfs(x-1,y,grid);
        int right = dfs(x+1,y,grid);
        max = Math.max(Math.max(Math.max(up,down),left),right);
        grid[x][y] = tmp;
        return grid[x][y]+max;

    }
    public int getMaximumGold(int[][] grid) {
        if(grid.length==0) return 0;
        int rows = grid.length;
        int cols = grid[0].length;
        int res = Integer.MIN_VALUE;
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                res = Math.max(res,dfs(i,j,grid));
            }
        }
        return res;
    }
}

路径和问题

    1. 寻找路径和是否等于目标值
      思路：为了节省一个变量直接用sum减去当前的节点值。当前为空直接返回false，如果已经遍历到叶子节点则比较root.val==sum;否则递归左子树和右子树。
      代码：
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root==null)  return false;
        if(root.left==null&&root.right==null) return sum==root.val;
        return hasPathSum(root.left, sum-root.val)||hasPathSum(root.right, sum-root.val);
    }
}
    1. 路径总和 II
      思路：和上面基础题的思路一致采用回溯+dfs，回溯每次要remove掉新添加进去的元素。
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private void dfs(TreeNode root, int targetSum, List<List<Integer>> res,List<Integer> tmp){
        if(root.left==null&&root.right==null&&root.val==targetSum){tmp.add(root.val);res.add(new ArrayList<>(tmp));tmp.remove(tmp.size()-1);return;}
        tmp.add(root.val);
        if(root.left!=null) dfs(root.left,targetSum-root.val,res,tmp);
        tmp.remove(tmp.size()-1);
        tmp.add(root.val);
        if(root.right!=null) dfs(root.right,targetSum-root.val,res,tmp);
        tmp.remove(tmp.size()-1);

    }
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null) return res;
        dfs(root,sum,res,new ArrayList<>());
        return  res;
    }
}

剑指 Offer 12. 矩阵中的路径

思路：从board的每个点从四周进行dfs搜索直到word的最后一个字符搜索完
代码：

class Solution {
    private boolean dfs(int x,int y,char[][]board,char[] words,int index){
    //如果越界或者当前的字符和棋盘当前的字符不等，返回false
        if(x<0||x>=board.length||y<0||y>=board[0].length||board[x][y]!=words[index])   return false;
        //如果word全部在棋盘找到返回true
        if(index==words.length-1) return true;
        //保留现场
        char tmp = board[x][y];
        board[x][y] = '#';
        //向上下左右dfs
        boolean res= dfs(x-1,y,board,words,index+1)||dfs(x+1,y,board,words,index+1)||dfs(x,y-1,board,words,index+1)||dfs(x,y+1,board,words,index+1);
        //还原现场
        board[x][y] = tmp;
        return res;

    }
    public boolean exist(char[][] board, String word) {
        char[] words = word.toCharArray();
        for(int i=0; i<board.length; i++){
            for(int j=0; j<board[0].length; j++){
                if(dfs(i,j,board,words,0))  return true;
            }
        }
        return false;
    }
}
dtzly
关注
专栏目录
回溯算法(细说版)
weixin_45014721的博客
09-14 406
文章目录一、求子集问题Leecode78Leecode90二、排列问题Solution46Solution47三、组合问题Solution77Solution17Solution39Solution40 一、求子集问题 添加链接描述 Leecode78 1.回溯三部曲 （1）确定递归函数参数及其返回值 返回值：不需要返回值，因为我们定义了全局变量数组path为子集收集元素，二维数组result存放子集组合。 参数：(int[] nums, int startIndex)其中nums是传
回溯算法的理解
young_man2的博客
08-02 882
回溯算法的理解
层序遍历二叉树
qq_31617121的博客
03-26 174
【点评】用到广度优先搜索，队列存入二叉树的节点，先进先出。 用levelLastNode表示每一层的最后一个节点，lastNode表示当前遍历到的最后一个节点，也就是最新的存入队列的节点。 从队列头弹出节点，查看左右子树，有的话压入队列尾，lastNode一直跟随更新。然后判断当前队列是不是这层的最后一个节点，是的话，更新下一层的最后一个节点是LastNode。 binary-tree-le...
Java刷题总结——回溯算法篇
最新发布
weixin_43381762的博客
08-07 229
当i=1时，ab明显不是回文的，若break则不会判断i++的循环，但是当i=4的时候能够得到回文串因此只能跳过本轮循环，而不是break终止循环。同45°的情况，当目标在（1，1），搜索135°则是第一层的是（0，2）即（row-1，col+1）回溯类似于遍历一颗二叉树，由于组合元素用过的不能重复，则每次递归的开始条件为i+1，即可去重。（2）aba，i=0，j=2，当i，j都为1时，都指向b，b肯定是回文的，省去判断。（1）a，由于a肯定是回文的，此时i=0，j=0，直接返回true，不用判断。
回溯法的总结
chenkaibsw的专栏
10-21 268
1.一维度问题 1）排列问题(leetCode 46号问题) 题目描述：输入数字1，2，3，输出它们的所有组合1 2 3 ,1 3 2, 2 1 3, 2 3 1,3 1 2, 3 2 1。 代码实现： 方法一： 使用index来标记temp数组的长度，当长度为3的时候，就停止。 每次for循环都是从0开始，但是已经取过的值使用flag标记。 class HuiSu{ sta...
算法分析论文——回溯算法的应用.zip
10-19
回溯算法是一种强大的问题求解方法，尤其在解决复杂组合优化问题时表现出高效性。它是一种试探性的解决问题的方法，通过逐步构建可能的解决方案，并在过程中不断检查这些解决方案的有效性。如果发现当前路径无法导出...
用栈、回溯算法设计迷宫程序
10-24
标题中的“用栈、回溯算法设计迷宫程序”指的是使用数据结构中的栈以及算法中的回溯法来解决迷宫问题。在这个问题中，我们通常将迷宫视为一个二维矩阵，其中1代表墙壁，0代表可通行的道路。目标是找到从起点到终点的...
回溯算法求数独的解
01-01
回溯算法则是解决数独问题的一种高效策略，它通过尝试填入数字并检查是否符合规则来逐步求解。 首先，我们需要理解回溯算法的基本思想。回溯法是一种试探性的解决问题的方法，它尝试分步地找出所有可能的解决方案，...
五大常用算法——回溯算法详解及经典例题，算法数据结构 五大常用算法
04-07
回溯算法是一种常用的搜索算法，它可以用于解决许多复杂的问题。回溯算法的基本思想是，通过不断地尝试和回溯来找到问题的解。它可以看作蛮力法穷举搜索的改进，能够避免搜索所有可能的解，从而提高搜索效率。 在...
PHP实现的回溯算法示例
10-19
回溯算法是一种在解决问题时，通过尝试所有可能的解决方案，并在发现某一步不满足条件时回退到上一步，甚至更早的一步，撤销刚才所做的选择，继续探索其他可能的分支，直到找到满足条件的解决方案或者所有可能性都...
java回溯算法解数独问题
08-26
"java回溯算法解数独问题" java回溯算法是一种常用的算法，可以用来解决数独问题。数独问题是指在一个9x9的矩阵中，填充数字1-9，使得每行、每列、每个3x3的子矩阵中数字不重复。java回溯算法的基本思路是，从第0行...
数独求解matlab代码-Sudoku-Solver:使用回溯算法解决任何可解决的数独问题的C++代码
05-28
使用回溯算法解决任何可解决的数独的c ++代码。 该代码已被即兴使用数字图像处理来分割数独中给出的行，以将数独的数据提取到9 * 9矩阵中。 下面给出了一个空白的数独以及另一个图像，这些图像显示了由matlab代码...
C++回溯算法实验报告
12-10
回溯算法是一种在问题的解空间树中，按照深度优先搜索策略，通过剪枝操作避免无效搜索，从而求解问题的算法。在这个C++实验中，我们分别通过两个实例来探讨回溯法的应用。 首先，实验的第一个问题是删数问题。这个...
浅析回溯算法
03-24
回溯算法是一种试探性的解决问题的方法，它尝试通过不断探索所有可能的解决方案来找到问题的答案，如果发现当前选择的路径无法到达目标状态，就会撤销选择，返回到上一步甚至更早的状态，继续尝试其他的可能性。...
backtracking_N皇后_01背包_回溯算法_售货员问题_图的m着色_
10-01
回溯算法是一种强大的搜索策略，常用于解决一系列的组合优化问题。它通过尝试所有可能的解决方案，当发现某个分支无法得到满足条件的解时，就回溯到上一个决策点，选择其他路径继续探索。本篇文章将深入探讨回溯算法...
手把手教你<leetcode>中的回溯算法——多一点套路
热门推荐
versencoder的博客
07-30 2万+
博主在学习回溯算法到应用其完成算法题经历了很多的困惑，查看别人博客的时候基本都是解决某个特定问题，而不是注重方法，相信不少读者看完和我一样一脸懵逼。所以博主想要尝试下写下自己总结的方法。希望这篇博客能够帮助和我一样在学习算法的人！
leetcode 练习
scutedu的博客
04-13 221
1.华为面试题一 #include <iostream> #include <string> #include <algorithm> using namespace std; class Solution { public: string reverseWords(string s) { reverse(s.begin(), s.e...
Android程序员面试会遇到的算法(part 3 深度优先搜索-回溯backtracking)
weixin_33851604的博客
05-09 118
上一遍文章我们过了一次广度优先算法，算是比较好理解的，因为模式比较固定，使用队列再进行while() 循环，既可以满足大部分时候的需求。这一次我们来开始学习/复习一下我们的深度优先算法。深度优先算法其实在很多地方都可以应用到，其实在我的看法，只要搜索集合相对固定，并且使用到递归的算法都可以算是深度优先。而且在学习完回溯算法的很多题目之后，大家也可以更直观的体验到，很多时候回溯也是暴力搜索的一种程序...
java 有序数组 频率,高频算法题解 java
weixin_39825722的博客
03-14 105
替换空格public void replaceSpace(){String s="abc de f ";String t= s.replace(" ","%20");System.out.println(t);}顺时针打印矩阵import java.util.ArrayList;import java.util.List;public class SpiralMatrix {public List...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值