LeetCode -- 回溯

最新推荐文章于 2023-05-30 18:37:56 发布

咖啡的假期

最新推荐文章于 2023-05-30 18:37:56 发布

阅读量159

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/u013146557/article/details/89225458

版权

leetcode 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

题目1. 列出所有子集

https://leetcode.com/problems/subsets/

题意简介：给定一个集合，给出所有子集。

题解：标准回溯问题，不过要注意有可能出现子集重复问题，所以最好先排个序，然后当相邻两个数相同时还要注意判断条件。

class Solution {
    List<List<Integer>> answerList = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        Arrays.sort(nums);
        solve(nums,0,new ArrayList<Integer>());
        return answerList;
    }
    
    void solve(int[] nums,int start,List<Integer> list){
        answerList.add(new ArrayList<Integer>(list));
        
        for(int i=start;i<nums.length;i++){
            if(i >start && nums[i] == nums[i-1])continue;  //i==start 的时候为正常计数
            list.add(nums[i]);       //加上此元素
            solve(nums,i+1,list);
            list.remove(list.size()-1);  //去除此元素
        }
    }
}

题目2 . 列出字符串能解析出的所有可能的ip地址

https://leetcode.com/problems/restore-ip-addresses/submissions/

题意简介：列出字符串能解析出的所有可能的ip地址

题解：回溯问题，注意一下边界条件，比如地址号只能有3位，且开头不能为0

class Solution {
    List<String> answerList = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        solve(s,0,new ArrayList<String>());
        return answerList;
    }
    
    void solve(String s,int m,List<String> list){
        if(list.size()>4)return;
        //ip地址长度不超过4位
        
        if(m == s.length() && list.size() == 4 ){  //字符串遍历完且长度刚好为4位
            String str = String.join(".",list);
            answerList.add(str);
        }
        
        for(int i = m;i<s.length() && i<m+3;i++){ //每一段的长度不会超过3位
            String substr = s.substring(m,i+1);
            int number = Integer.valueOf(substr);
            if(number >=0 &&number <= 255){
                list.add(substr);
                solve(s,i+1,list);
                list.remove(list.size()-1);
            }
            if(s.charAt(m) == '0')break;  
            //不能出现以0开头的字段   如 255.01.23.255,，某个字段开头是0的话那个字段只能是0
        }
        
    }
}

题目3 . 矩阵内部字符串匹配

https://leetcode.com/problems/word-search/

提目简介：给一个字符串，判断是否能在矩阵中找出一条连续的路线匹配该字符串。

解法：标准回溯问题

class Solution {
    public boolean exist(char[][] board, String word) {
        
        int m = board.length;
        int n = board[0].length;
        if(word.length() ==0 || m*n < word.length())return false;
        for(int i=0;i< m;i++){
            for(int j=0;j<n;j++){
                if(dfs(board,i,j,0,word)){
                    return true;
                }
               
            }
        
        }
        return false;
        
    }
    
    
    boolean dfs(char[][] board,int i,int j,int n,String word){
        if(n == word.length())return true;
        
        if(i< 0 || j<0 || i>=board.length||j>=board[0].length||word.charAt(n)!=board[i][j] )return false;  //判断边界条件，i和j没有超过边界且 没有走过
       
        
        board[i][j] = ' ';
        boolean can = dfs(board,i,j+1,n+1,word) || dfs(board,i+1,j,n+1,word) || dfs(board,i,j-1,n+1,word) || dfs(board,i-1,j,n+1,word);
        board[i][j] = word.charAt(n);
        
        return can;
    }
}

题目 4.输出数组所有可能排序

https://leetcode.com/problems/permutations-ii/

题目简介：输出数组所有可能排序

题解：标准回溯问题，但是要注意重复数字的问题，每次交换前都将要交换的数字存进Set中，如果Set中已经有了该数字，则不用交换，因为肯定重复了。

class Solution {
    List<List<Integer>> totleList = new ArrayList<>();
    
    public List<List<Integer>> permuteUnique(int[] nums) {
        if(nums.length == 0)return totleList;
        dfs(nums,0);
        return totleList;
        
    }
    
    void dfs(int[] nums,int index){
        if(index == nums.length){
           
             List<Integer> list = new ArrayList<Integer>();
             String a="";
             for(int t:nums){
                 list.add(t);
                 a+= String.valueOf(t);
             }
            totleList.add(list);
            
            return;
        }
        
        Set<Integer> set = new HashSet<>(); //将所有交换过的数字存起来，重复的数字不用交换，因为第一遍的时候已经交换过了
        for(int i=index;i<nums.length;i++){
            if(set.add(nums[i])){  //不重复数字才交换，  注意 set.add  添加失败时返回false
                swap(nums,index,i);
                dfs(nums,index+1);
                swap(nums,index,i);
            } 
        }
    }
    
    void swap(int[] nums,int i,int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    
}

题目5. N皇后问题

https://leetcode.com/problems/n-queens/

题目简介： N皇后在N*N的棋盘中摆放，8个方位都不能有其他皇后。

题解：经典回溯问题，关键就是判断皇后能不能摆放用一个place【】数组存放皇后摆放位置，i表示第几行，place[i]表示皇后摆放在这一行的第几列. 皇后可摆放判定条件是不存在同一列的，还有斜率的绝对值为1 的。

class Solution {
    List<List<String>>  totlelistlist = new ArrayList<>();
    int[] place;
    public List<List<String>> solveNQueens(int n) {
        if(n <= 0)return totlelistlist;
        place = new int[n];
        dfs(n,0);
        return totlelistlist;
    }
    
    boolean canPlace(int x,int y){
        for(int i=0;i<x;i++){
            //在同一列也不行
            if(place[i] == y)return false;
            
            //x斜率为1或者-1都不行
            if(Math.abs((float)(y-place[i])/(x-i)) == 1.0)return false;
        }
        return true;
    }
    
    List<String> print(int n){
        List<String> list = new ArrayList<>();
        char[] c = new char[n];
        Arrays.fill(c,'.');
       
        for(int i=0;i<n;i++ ){
            c[place[i]] = 'Q';
            String str =  new String(c);
            list.add(str);
            c[place[i]] = '.';
        }
        return list;
    }
    
    void  dfs(int n,int index){
        if(index == n){
            totlelistlist.add(print(n));
            return;
        }
        
        for(int i=0;i<n;i++){
            if(canPlace(index,i)){
                place[index] = i;
                dfs(n,index+1);
                place[index] = -1;
            }
        }
    }
}

题目6. N对括号匹配

https://leetcode.com/problems/generate-parentheses/

题目简介：输出N对括号所有匹配。

题解：标准回溯问题，每次只有两种情况输出左括号或者输出右括号，限定规则就是左括号小于N，右括号小于左括号且小于N。结束条件是左括号数等于右括号数等于 N。

class Solution {
    List<String> list = new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        dfs(n,0,0,"");
        return list;
    }
    
    void dfs(int n,int countl,int countr,String str){
        if(countl > n || countr >n)return;  //任意一个大于N则失败
        if(countl == countr && countr == n){
            list.add(str);
            return;
        }
        
        if(countl < n){
            str +="(";
            countl++;
            dfs(n,countl,countr,str);
            countl--;
            str = str.substring(0,str.length()-1);
        }
        
        if(countr < n && countr < countl){
            str +=")";
            countr++;
            dfs(n,countl,countr,str);
            countr--;
            str = str.substring(0,str.length()-1);
        }
    }
}

题目7. 单词变形

https://leetcode.com/problems/word-ladder/

题目简介：startword单词每次只能变一个字母,且必须出现在wordlist中，最终变成endword.

题解：层次遍历，把每个单词所有字母都替换一遍，若存在于wordlist中则加入这一层的节点中用queue存储，同时从wordlist移除。当某一层最先出现endword时，层高就是最短路径长度。

class Solution {
    
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Set<String> set = new HashSet<>(wordList);
        if(!set.contains(endWord))return 0;
        Deque<String> queue = new ArrayDeque<>();
           
        queue.offer(beginWord);
        set.remove(beginWord);
        
        int level = 1;
        while(!queue.isEmpty()){ //用队列保存
           
           int length = queue.size(); //队列的层长度
           for(int i=0;i<length;i++){  //层次遍历
              String word = queue.poll(); //取出一个
              if(word.equals(endWord)){
                  return level;
              }else{
                  char[] chars = word.toCharArray(); //变成char数组
                  for(int j=0;j<chars.length;j++){
                      char prevChar = chars[j];
                      for(int k=0;k<26;k++){
                         chars[j] = (char)(k+'a');  //替换一个元素
                          String newStr = new String(chars);
                          if(set.contains(newStr)){  //是否在set中
                              queue.offer(newStr);
                              set.remove(newStr);
                          }
                      }
                      chars[j] = prevChar;   //换回来
                  }
              }
           }
           level++;
       }
        return 0;
    }
}

题目8. 围棋环绕区域

https://leetcode.com/problems/surrounded-regions/

题目简介：将所有被X围起来的O变成X（即为吃掉），边上不算

题解：简单的回溯题型，只用从四边找到为O的点，然后向内深度遍历即可

class Solution {
   
    public void solve(char[][] board) {
        if(board.length == 0)return;
        for(int i=0;i<board.length;i++){
            if(board[i][0] == 'O')
                dfs(board,i,0,new boolean[board.length][board[0].length]);
                
            if(board[i][board[0].length-1] == 'O')
                dfs(board,i,board[0].length-1,new boolean[board.length][board[0].length]);
        }
        
        for(int j=0;j<board[0].length;j++){
            if(board[0][j] == 'O')
                dfs(board,0,j,new boolean[board.length][board[0].length]);
                
            if(board[board.length-1][j] == 'O')
                dfs(board,board.length-1,j,new boolean[board.length][board[0].length]);
        }
        
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[0].length;j++){
                if(board[i][j] == '*')board[i][j] ='O';
                else{
                    board[i][j] = 'X';
                }
                 
            }
        }
        
    }
    
    void dfs(char[][] board,int x,int y,boolean[][] hasPlace){
        int[] x_o = new int[]{1,0,-1,0};
        int[] y_o = new int[]{0,1,0,-1};
        
        hasPlace[x][y] = true;
        board[x][y] = '*';
        
        for(int i=0;i<4;i++){
            int newx = x+x_o[i];
            int newy = y+y_o[i];
            if(cango(board,newx,newy,hasPlace)){
                dfs(board,newx,newy,hasPlace);
            }
        }
        
    }
    
    boolean cango(char[][] board,int x,int y,boolean[][] hasPlace){
        if(x <0 ||x>= board.length || y <0 ||y>=board[0].length|| hasPlace[x][y] ==true || board[x][y] == 'X')return false;
        return true;
    }
}