leetcode之回溯刷题总结2

最新推荐文章于 2024-08-06 17:50:14 发布
最新推荐文章于 2024-08-06 17:50:14 发布
阅读量539 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： leetcode 深度优先 算法 回溯 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/122977410
版权

leetcode之回溯刷题总结2

1-解数独
题目链接：题目链接戳这里！！！

思路：递归+回溯
首先预处理board数组，如果是数字，则使用row[i][digit]标记数字digit+1在第i行出现过，column[j][digit]表示数字digit+1在第j列出现过，block[i/3][j/3][digit]数字digit+1在3*3的方格内出现过，后面递归依次尝试所有数字，如果满足条件则放入，否则回溯到最初位置继续尝试。

class Solution {
    List<int[]> list = new ArrayList<>() ;
    boolean [][] row = new boolean [9][9] ;
    boolean [][] column = new boolean [9][9] ;
    boolean [][][] block = new boolean [3][3][9] ;
    boolean valid = false ;
    public void solveSudoku(char[][] board) {
        for(int i=0; i<9; i++){
            for(int j=0; j<9; j++){
                if(board[i][j]=='.'){
                    list.add(new int []{i,j}) ;
                }else{
                    int digit = board[i][j] - '0' - 1;
                    row[i][digit] = column[j][digit] = block[i/3][j/3][digit] = true ;
                }
            }
        }
        dfs(0,board) ;
    }
    public void dfs(int k, char [][] board){
        if(k==list.size()){
            valid = true ;
            return ;
        }
       int [] space = list.get(k) ;
       int i = space[0], j = space[1] ;
       for(int digit=0; digit<9 && !valid; digit++){
           if(!row[i][digit] && !column[j][digit] && !block[i/3][j/3][digit]){
               row[i][digit] = column[j][digit] = block[i/3][j/3][digit] = true ;
               board[i][j] = (char)(digit + '0' + 1) ;
               dfs(k+1, board) ;
               row[i][digit] = column[j][digit] = block[i/3][j/3][digit] = false ;
           }
       }
    }
}

在这里插入图片描述
2-N皇后
题目链接：题目链接戳这里！！！

思路：递归+回溯法
皇后的走法是：可以横直斜走，格数不限。因此要求皇后彼此之间不能相互攻击，等价于要求任何两个皇后都不能在同一行、同一列以及同一条斜线上。
回溯的具体做法是：使用一个数组记录每行放置的皇后的列下标，依次在每一行放置一个皇后。每次新放置的皇后都不能和已经放置的皇后之间有攻击：即新放置的皇后不能和任何一个已经放置的皇后在同一列以及同一条斜线上，并更新数组中的当前行的皇后列下标。当 N 个皇后都放置完毕，则找到一个可能的解。当找到一个可能的解之后，将数组转换成表示棋盘状态的列表，并将该棋盘状态的列表加入返回列表。

class Solution {
    List<List<String>> ans = new ArrayList<>() ;
    public List<List<String>> solveNQueens(int n) {
        Set<Integer> columns = new HashSet<>() ;
        Set<Integer> diagonals1 = new HashSet<>() ;
        Set<Integer> diagonals2 = new HashSet<>() ;
        int [] queues = new int [n] ;
        Arrays.fill(queues,-1) ;
        dfs(0,n,columns,diagonals1,diagonals2, queues) ;
        return ans ;
    }
    public void dfs(int row, int n, Set<Integer> columns, Set<Integer> diagonals1, Set<Integer> diagonals2, int [] queues){
        if(row==n){
            List<String> board = f(queues,n) ;
            ans.add(new ArrayList<>(board)) ;
            return ;
        }
        for(int i=0; i<n; i++){
            if(columns.contains(i)){
                continue ;
            }
            int diagonal1 = row + i ;
            if(diagonals1.contains(diagonal1)){
                continue ;
            }
            int diagonal2 = row - i ;
            if(diagonals2.contains(diagonal2)){
                continue ;
            }
            queues[row] = i ;
            columns.add(i) ;
            diagonals1.add(diagonal1) ;
            diagonals2.add(diagonal2) ;
            dfs(row+1, n, columns, diagonals1, diagonals2,queues) ;
            queues[row] = -1  ;
            columns.remove(i) ;
            diagonals1.remove(diagonal1) ;
            diagonals2.remove(diagonal2) ;

        }
    }
    public List<String> f(int [] queues, int n){
        List<String> list = new ArrayList<>() ;
        for(int i=0; i<n; i++){
            char [] a = new char [n] ;
            Arrays.fill(a,'.') ;
            a[queues[i]] = 'Q' ;
            list.add(new String(a)) ;
        }
        return list ;
    }
}

在这里插入图片描述
3-N皇后II
题目链接：题目链接戳这里！！！

思路：递归+回溯
这题和上一题思路一样，每一次只需要返回满足条件的种类数量即可。

class Solution {
    public int totalNQueens(int n) {
        Set<Integer> columns = new HashSet<>() ;
        Set<Integer> diagonals1 = new HashSet<>() ;
        Set<Integer> diagonals2 = new HashSet<>() ;
        return dfs(0,n,columns,diagonals1,diagonals2) ;
    }
    public int dfs(int row, int n, Set<Integer> columns, Set<Integer> diagonals1, Set<Integer> diagonals2){
        if(row==n){
            return 1 ;
        }else{
            int cnt = 0 ;
        for(int i=0; i<n; i++){
            if(columns.contains(i)){
                continue ;
            }
            int diagonal1 = row + i ;
            if(diagonals1.contains(diagonal1)){
                continue ;
            }
            int diagonal2 = row - i ;
            if(diagonals2.contains(diagonal2)){
                continue ;
            }
            columns.add(i) ;
            diagonals1.add(diagonal1) ;
            diagonals2.add(diagonal2) ;
            cnt += dfs(row+1,n,columns,diagonals1,diagonals2) ;
            columns.remove(i) ;
            diagonals1.remove(diagonal1) ;
            diagonals2.remove(diagonal2) ;
        } 
          return cnt ;
        }
      
    }
}

在这里插入图片描述
4-字母大小写全排列
题目链接：题目链接戳这里！！！

思路1：如果下一个字符 c 是字母，将当前已遍历过的字符串全排列复制两份，在第一份的每个字符串末尾添加 lowercase©，在第二份的每个字符串末尾添加 uppercase©。

class Solution {
    public List<String> letterCasePermutation(String s) {
        List<StringBuilder> res = new ArrayList<>() ;
        List<String> list = new ArrayList<>() ;
        res.add(new StringBuilder()) ;

        for(char c : s.toCharArray()){
            int n = res.size();
            if(Character.isLetter(c)){
            for(int i=0; i<n; i++){
                res.add(new StringBuilder(res.get(i))) ;
                res.get(i).append(Character.toUpperCase(c)) ;
                res.get(n+i).append(Character.toLowerCase(c)) ;
            }
            }else{
                for(int i=0; i<n; i++){
                    res.get(i).append(c) ;
                }
            }
        }
        for(StringBuilder ans : res){
            list.add(ans.toString()) ;
        }
        return list ;
    }
}

在这里插入图片描述
思路2：搜索+回溯
递归搜索，如果是数字，直接添加，字母则转换之后添加，同时，每一轮搜索完成，需要回溯到原始状态。

class Solution {
    List<String> res = new ArrayList<>() ;
    char [] c ;
    public List<String> letterCasePermutation(String s) {
      c = s.toCharArray() ;
      dfs(0,new StringBuilder()) ;
      return res ;
    }
    public void dfs(int idx, StringBuilder str){
        if(idx>=c.length){
            res.add(str.toString()) ;
            return ;
        }
        dfs(idx+1,str.append(c[idx])) ;
        str.deleteCharAt(idx) ;
     
        if(c[idx]>='a'){
            dfs(idx+1,str.append((char)(c[idx]-32))) ;
             str.deleteCharAt(idx) ;
        }else if(c[idx]>='A'){
            dfs(idx+1,str.append((char)(c[idx]+32))) ;
             str.deleteCharAt(idx) ;
        }
          
    }
}

在这里插入图片描述
思路3：递归法

class Solution {
    List<String> res = new ArrayList<>() ;
    public List<String> letterCasePermutation(String s) {
      char []c = s.toCharArray() ;
      dfs(0,c) ;
      return res ;
    }
    public void dfs(int idx, char [] c){
        if(idx>=c.length){
            res.add(new String(c)) ;
            return ;
        }
      
      char ch = c[idx] ;
       if(Character.isLetter(ch)){
           c[idx] = Character.toLowerCase(ch) ;
           dfs(idx+1,c) ;
           c[idx] = Character.toUpperCase(ch) ;
           dfs(idx+1,c) ;
       }else{
           dfs(idx+1,c) ;
       }
          
    }
}

在这里插入图片描述
5-单词搜索
题目链接：题目链接戳这里！！！

思路：搜索+回溯
压着四个方向搜索，每一次搜索标记，未被访问且没有越界，则可以继续搜索，每轮搜索完成需要标记数组需要回溯到原始状态。

class Solution {
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    boolean flags = false ;
    public boolean exist(char[][] board, String word) {
        boolean [][] vis = new boolean[board.length][board[0].length] ;
        for(int i=0;i<board.length; i++){
            for(int j=0; j<board[0].length; j++){
                boolean flag = dfs(board,i,j,vis,word,0) ;
                if(flag){
                    return true ;
                }
            }
        }
        return false ;
    }
    public boolean dfs(char [][]board, int x, int y, boolean [][] vis, String word,int begin){
        if(board[x][y]!=word.charAt(begin)){
            return false ;
        }
        if(begin==word.length()-1){
            return true ;
        }
        
        vis[x][y] = true ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>board.length-1 || ty>board[0].length-1){
                continue ;
            }
            if(!vis[tx][ty]){
            flags = dfs(board,tx,ty,vis,word,begin+1) ;
            if(flags){
                return true ;
            }
            }
        }
          vis[x][y] = false ;
        return flags ;
    }
}

在这里插入图片描述
6-黄金矿工
题目链接：题目链接戳这里！！！

思路：搜索+回溯
沿着四个方向搜索，当前值大于0则继续搜索，每次搜索要求和，同时标记为0，同时求出最大值，搜索完后后，要回溯到原始状态。

class Solution {
    int res = 0;
    int [] dx = {-1,1,0,0} ;
    int [] dy = {0,0,-1,1} ;
    public int getMaximumGold(int[][] grid) {
        for(int i=0; i<grid.length; i++){
            for(int j=0; j<grid[0].length; j++){
                if(grid[i][j]>0){ 
                    dfs(grid,i,j,0) ;
                }
            }
        }
        return res ;
    }
    public void dfs(int [][] grid, int x, int y, int sum){
        if(x<0 || y<0 || x>grid.length-1 || y>grid[0].length-1){
                return ;
        }
       int temp = grid[x][y] ;
        sum += grid[x][y] ;
        grid[x][y] = 0 ;
        res = Math.max(res,sum) ;
        for(int i=0; i<4; i++){
            int tx = x + dx[i] ;
            int ty = y + dy[i] ;
            if(tx<0 || ty<0 || tx>grid.length-1 || ty>grid[0].length-1){
                continue ;
        }
            if(grid[tx][ty]>0){
                dfs(grid,tx,ty,sum) ;
            }
        }
        sum -= grid[x][y] ;
        grid[x][y] = temp ;
    }
}

在这里插入图片描述
7-活字印刷
题目链接：题目链接戳这里！！！

思路：递归+回溯+set集合去重

class Solution {
    public int numTilePossibilities(String tiles) {
        Set<String> res = new TreeSet<>() ;
        int n = tiles.length() ;
        boolean [] vis = new boolean [n]  ;
        dfs(res,tiles,vis,new StringBuilder()) ;
        return res.size()-1 ;
    }
    public void dfs(Set<String> res, String tiles, boolean [] vis, StringBuilder temp){
        res.add(temp.toString()) ;
        for(int i=0; i<tiles.length(); i++){
            if(!vis[i]){
                vis[i] = true ;
                temp.append(tiles.charAt(i)) ;
                dfs(res,tiles,vis,temp) ;
                temp.deleteCharAt(temp.length()-1) ;
                vis[i] = false ;
            }
        }
    }
}

在这里插入图片描述
这样写效率高一些。

class Solution {
    int cnt = 0 ;
    public int numTilePossibilities(String tiles) {
       char [] c = tiles.toCharArray() ;
       Arrays.sort(c) ;
       boolean [] vis = new boolean[c.length] ;
       for(int i=1; i<=tiles.length(); i++){
           dfs(c,vis,0,i) ;
       }
       return cnt ;
    }
    public void dfs(char [] c, boolean [] vis, int cur, int target){
        if(cur == target){
            cnt ++ ;
            return ;
        }
        for(int i=0; i<c.length; i++){
            if(vis[i]){
                continue ;
            }
            if(i>0 && c[i-1]==c[i] && !vis[i-1]){
                continue ;
            }
            vis[i] = true ;
            cur += 1 ;
            dfs(c,vis,cur,target) ;
            cur -= 1 ;
            vis[i] = false ;
        }
    } 
}

在这里插入图片描述

今天就止步到这里了，我要返校了，理工见！！！

nuist__NJUPT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 1219 黄金矿工(回溯法)
Fann
11-04 371
class Solution { public int getMaximumGold(int[][] grid) { } } 解决: 1.哪些点可以作为起始点? 遍历数组,只要不是0的位置都可以作为起始点 2.寻找下一步位置的时候,如何判断走哪里 用一个相同大小的boolean数组来记录走过的位置**,走过的位置记为true** 3.下一个位置可以走哪里? ...
leetcode:leetcode刷题记录与总结
04-11
《LeetCode刷题记录与总结》 LeetCode，一个广受欢迎的在线编程挑战平台，汇聚了各类算法题目，是程序员提升编程技能、准备面试的重要工具。这篇文档将围绕我在LeetCode上的刷题经历，分享一些关键知识点和学习心得...
2022.02.05 - 230.黄金矿工
阿财继续努力
02-05 191
文章目录1. 题目2. 思路(1) DFS+回溯法3. 代码 1. 题目 2. 思路 (1) DFS+回溯法 从每一个有黄金的格子开始向上下左右四个方向进行深度优先搜索，若不能向四周搜索时，则比较当前格子累计的黄金是否大于最大黄金数。 每探索一个格子，将该格子的值置为相反数，标记该格子已经被搜索过，回溯时恢复该格子的值。 3. 代码 public class Test { public static void main(String[] args) { } } class Solu
四种GCC内置位运算函数
海纳百川
09-01 3735
int __builtin_ffs (unsigned int x) 返回x的最后一位1的是从后向前第几位，比如7368（1110011001000）返回4。int __builtin_clz (unsigned int x) 返回前导的0的个数。int __builtin_ctz (unsigned int x) 返回后面的0个个数，和__builtin_clz相对。int __built
黄金矿工
weixin_41791402的博客
10-07 736
你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为m * n 的网格 grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。 为了使收益最大化，矿工需要按以下规则来开采黄金： 每当矿工进入一个单元，就会收集该单元格中的所有黄金。 矿工每次可以从当前位置向上下左右四个方向走。 每个单元格只能被开采（进入）一次。 不得开采（...
leetcode之回溯刷题总结1
nuist_NJUPT的博客
02-16 643
leetcode之回溯刷题总结1 回溯法：一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化抛弃该解，即回溯并且再次尝试。 1-全排列 题目链接：题目链接戳这里！！！ 思路：这个问题可以看作有 n 个排列成一行的空格，我们需要从左往右依此填入题目给定的 n 个数，每个数只能使用一次。那么很直接的可以想到一种穷举的算法，即从左往右每一个位置都依此尝试填入一个数，看能不能填完这 n 个空格，在程序中我们可以用「回溯法」来模拟
leetcode之回溯刷题总结3
nuist_NJUPT的博客
03-01 310
leetcode之回溯刷题总结3 1-复原IP地址 题目链接：题目链接戳这里！！！ 思路：回溯法 依次枚举截取的字符串，如果满足要求，继续枚举，否则，回到原来的状态，直到每次出现了三个逗号，并且后面的字符串满足IP地址的要求，则最终的合格IP地址加入集合。 class Solution { List<String> res = new ArrayList<>() ; StringBuffer path = new StringBuffer() ; pu
【leetcode】回溯刷题总结
zs16113的博客
04-27 198
有递归就有回溯，递归与回溯相辅相成。回溯搜索法是纯暴力搜索算法。一般的回溯问题都可以抽象为树结构，树的深度为递归次数，树的宽度为候选集合大小。
leetcode之回溯法刷题总结（C++)
L_smartworld的博客
08-08 248
基础知识： 总结第一波：https://blog.csdn.net/L_smartworld/article/details/106429270 总结第二波：https://blog.csdn.net/L_smartworld/article/details/107124243 下面是力扣1-150题中的回溯题目： 博客索引： 17.电话号码的字母组合：https://blog.csdn.net/L_smartworld/article/details/106602102 ...
leetcode刷题知识点总结（刷题必备）
ingenuou_的博客
05-18 2135
leetcode刷题知识点总结（刷题必备）
Leetcode:LeetCode 刷题总结
05-11
8. **排序与查找**：快速排序、归并排序、二分查找等经典算法在LeetCode中也有体现，例如"三数之和"（3Sum）要求找出数组中所有使得三个数之和为零的三元组。 9. **哈希表**：哈希表在解决查找和去重问题中非常有用...
_leetcode：leetcode刷题之旅
02-23
本项目“_leetcode：leetcode刷题之旅”显然是一位热衷于Java技术并致力于LeetCode刷题的程序员的心血结晶。 在这个项目中，`_leetcode-master`很可能是一个包含了该程序员在LeetCode上刷题的整个过程的代码仓库。...
入门算法leetcode面试题刷题
09-14
本篇文章将围绕“入门算法leetcode面试题刷题”这一主题展开讨论，重点解析其中提到的关键知识点，包括算法基础、常用及高级数据结构、递归与回溯、排序算法、深度与广度优先搜索、动态规划、二分搜索与贪婪算法以及...
LeetCode：LeetCode刷题思路
02-18
本资源“LeetCode刷题思路”似乎是一个关于如何有效地解决LeetCode上问题的指南，可能包含了对常见算法和数据结构问题的策略、技巧和解题思路。下面，我们将深入探讨LeetCode及其相关的知识点。 首先，LeetCode的...
5力扣：最长回文子串
m0_75015083的博客
08-02 326
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
LeetCode Hard｜【25. K 个一组翻转链表】
最新发布
糖炒栗子
08-06 265
首先，做整表翻转的时候，我们的逻辑非常简单。这里简单直观多了，最大的区别是什么呢？
力扣399.除法求值
Pisasama的博客
08-06 153
【代码】力扣399.除法求值。
Leetcode 第 135 场双周赛题解
ProgramNovice的博客
08-03 921
Leetcode 第 135 场双周赛题解
LeetCode题解：算法刷题攻略
在刷题的过程中，你将接触到各种类型的算法问题，例如动态规划、二分查找、图论、回溯、贪心策略、排序和搜索等。通过这些题目，你可以深入理解并熟练掌握这些算法的实现和应用。此外，使用C++11标准可以让你了解并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值