leetcode（回溯算法专题）

最新推荐文章于 2023-03-15 22:29:53 发布

Listen·Rain

最新推荐文章于 2023-03-15 22:29:53 发布

阅读量868

点赞数 1

分类专栏：笔记文章标签：操作系统 leetcode 散列表

本文链接：https://blog.csdn.net/qq_46517733/article/details/121536363

版权

笔记专栏收录该内容

20 篇文章 4 订阅

订阅专栏

回溯算法

1.导论
2.编程题

1.导论

递归中隐藏着回溯
回溯算法的本质是穷举
回溯优化：剪枝
回溯法解决问题：

组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

回溯法解决的问题可以抽象为树形结构

2.编程题

2.1 77. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按任何顺序返回答案。
1 <= n <= 20
1 <= k <= n

class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n,k,1);
        return ans;
    }
    private void backtrack(int n,int k,int index){
        if(path.size() == k){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<=n;++i){
            path.add(i);
            backtrack(n,k,i+1);
            path.remove(path.size()-1);
        }
    }
}

//优化
class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtrack(n,k,1);
        return ans;
    }
    private void backtrack(int n,int k,int index){
        if(path.size() == k){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<=n-(k-path.size())+1;++i){
            path.add(i);
            backtrack(n,k,i+1);
            path.remove(path.size()-1);
        }
    }
}

class Solution {
    List<Integer> temp = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();

    public List<List<Integer>> combine(int n, int k) {
        dfs(1, n, k);
        return ans;
    }

    public void dfs(int cur, int n, int k) {
        // 剪枝：temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
        if (temp.size() + (n - cur + 1) < k) {
            return;
        }
        // 记录合法的答案
        if (temp.size() == k) {
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        // 考虑选择当前位置
        temp.add(cur);
        dfs(cur + 1, n, k);
        temp.remove(temp.size() - 1);
        // 考虑不选择当前位置
        dfs(cur + 1, n, k);
    }
}

2.2 216. 组合总和 III

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

说明：

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

class Solution {
    List<Integer> path = new ArrayList<>();
    List<List<Integer>> ans = new LinkedList<>();
    int sum=0;
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtrack(k,n,1);
        return ans;
    }
    private void backtrack(int k,int n,int index){
        if(path.size()==k){
            if(sum == n) ans.add(new ArrayList(path));
            return;
        }
        for(int i=index;i<=9;++i){
            sum += i;
            path.add(i);
            backtrack(k,n,i+1);
            sum -= i;
            path.remove(path.size()-1);
        }
    }
}

2.3 17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
0 <= digits.length <= 4
digits[i] 是范围 [‘2’, ‘9’] 的一个数字。
在这里插入图片描述

class Solution {
    List<String> ans = new ArrayList<String>();
    StringBuilder path = new StringBuilder();
    String[] arr = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    public List<String> letterCombinations(String digits) {
        if(digits.equals("")){
            return new ArrayList();
        }
        backTracking(0,digits);
        return ans;
    }

    public void backTracking(int index,String digits){
        if(index == digits.length()){
            ans.add(path.toString());
            return;
        }

        int num = Integer.parseInt(digits.substring(index,index+1));

        for(int i=0;i<arr[num].length();++i){
            path.append(arr[num].charAt(i));
            backTracking(index+1,digits);
            path.deleteCharAt(path.length()-1);
        }
    }
}

2.4 39. 组合总和

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

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。

对于给定的输入，保证和为 target 的唯一组合数少于 150 个。

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都是独一无二的。
1 <= target <= 500

class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backtrack(candidates,target,0);
        return ans;
    }
    private void backtrack(int[] candidates,int target,int index){
        if(sum > target) return;
        if(sum == target){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<candidates.length;++i){
            sum += candidates[i];
            path.add(candidates[i]);
            backtrack(candidates,target,i);
            sum -= candidates[i];
            path.remove(path.size()-1);
        }
    }
}
//优化
class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates,target,0);
        return ans;
    }
    private void backtrack(int[] candidates,int target,int index){
        if(sum == target){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;(i<candidates.length) && (sum+candidates[i]<=target);++i){
            sum += candidates[i];
            path.add(candidates[i]);
            backtrack(candidates,target,i);
            sum -= candidates[i];
            path.remove(path.size()-1);
        }
    }
}

class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates,target,0);
        return ans;
    }
    private void backtrack(int[] candidates,int target,int index){
        if(target == 0){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;(i<candidates.length) && (target-candidates[i]>=0);++i){
            path.add(candidates[i]);
            backtrack(candidates,target-candidates[i],i);
            path.remove(path.size()-1);
        }
    }
}

2.5 40. 组合总和 II

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

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

注意：解集不能包含重复的组合。
1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates,target,0);
        return ans;
    }
    private void backtrack(int[] candidates,int target,int index){
        if(sum > target) return;
        if(sum == target){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<candidates.length;++i){
            if(i>index && candidates[i] == candidates[i-1]) continue;
            sum += candidates[i];
            path.add(candidates[i]);
            backtrack(candidates,target,i+1);
            sum -= candidates[i];
            path.remove(path.size()-1);
        }
    }
}
//优化
class Solution {
    List<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates,target,0);
        return ans;
    }
    private void backtrack(int[] candidates,int target,int index){
        if(sum == target){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<candidates.length && sum+candidates[i]<=target;++i){
            if(i>index && candidates[i] == candidates[i-1]) continue;
            sum += candidates[i];
            path.add(candidates[i]);
            backtrack(candidates,target,i+1);
            sum -= candidates[i];
            path.remove(path.size()-1);
        }
    }
}

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

2.6 131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。

回文串是正着读和反着读都一样的字符串。
1 <= s.length <= 16
s 仅由小写英文字母组成

class Solution {
    List<List<String>> ans = new ArrayList<>();
    List<String> path = new LinkedList<>();
    public List<List<String>> partition(String s) {
        backtrack(s,0);
        return ans;
    }
    
    private void backtrack(String s,int index){
        if(index == s.length()){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=index;i<s.length();++i){
            String temp = s.substring(index,i+1);
            if(check(temp)){
                path.add(temp);
                backtrack(s,i+1);
                path.remove(path.size()-1);
            }
        }
    }

    private boolean check(String s){
        int l = 0;
        int r = s.length()-1;
        while(l<r){
            if(s.charAt(l) != s.charAt(r)){
                return false;
            }
            ++l;
            --r;
        }
        return true;
    }
}

2.7 93. 复原 IP 地址

有效 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你不能重新排序或删除 s 中的任何数字。你可以按任何顺序返回答案。
0 <= s.length <= 20
s 仅由数字组成

class Solution {
    List<String> ans = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    int count = 0;
    public List<String> restoreIpAddresses(String s) {
        backtrack(s,0);
        return ans;
    }
    private void backtrack(String s,int index){
        if(count == 4){
            if(path.length() == (s.length()+3)){
                ans.add(path.toString());
            }
            return;
        }
        for(int i=index;i<s.length();++i){
            String temp = s.substring(index,i+1);
            if(isValid(temp)){
                if(path.length() != 0){
                    temp = "." + temp;
                }
                path.append(temp);
                ++count;
                backtrack(s,i+1);
                --count;
                path.delete(path.length()-temp.length(),path.length());
            }else{
                break;
            }
        }

    }
    private boolean isValid(String s){
        int num = Integer.parseInt(s);
        if(s.charAt(0) == '0' && s.length()>1){
            return false;
        }
        if(num>=0 && num<=255){
            return true;
        }
        return false;
    }
}

2.8 78. 子集

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按任意顺序返回解集。
1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素互不相同

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backtrack(nums,0);
        return ans;
    }
    private void backtrack(int[] nums,int index){
        ans.add(new ArrayList<>(path));
        if(index == nums.length){
            return;
        }
        for(int i=index;i<nums.length;++i){
            path.add(nums[i]);
            backtrack(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

class Solution {
    List<Integer> t = new ArrayList<Integer>();
    List<List<Integer>> result= new ArrayList<List<Integer>>(); 
    public List<List<Integer>> subsets(int[] nums) {
        dfs(0,nums);
        return result;
    }
    public void dfs(int cur,int[] nums){
        if(cur == nums.length){
            result.add(new ArrayList<Integer>(t));
            return;
        }
        t.add(nums[cur]);//选择
        dfs(cur+1,nums);
        t.remove(t.size()-1);//不选择
        dfs(cur+1,nums);
    }
}

2.9 90. 子集 II

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

解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。
1 <= nums.length <= 10
-10 <= nums[i] <= 10

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backtrack(nums,0);
        return ans;
    }
    private void backtrack(int[] nums,int index){
        ans.add(new ArrayList<>(path));
        if(index == nums.length){
            return;
        }
        for(int i=index;i<nums.length;++i){
            if(i>0 && nums[i] == nums[i-1] && !used[i-1]){
                continue;
            }
            used[i]=true;
            path.add(nums[i]);
            backtrack(nums,i+1);
            used[i] = false;
            path.remove(path.size()-1);
        }
    }
}

class Solution {
    List<Integer> t = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        dfs(false, 0, nums);
        return ans;
    }

    public void dfs(boolean choosePre, int cur, int[] nums) {
        if (cur == nums.length) {
            ans.add(new ArrayList<Integer>(t));
            return;
        }
        dfs(false, cur + 1, nums);
        if (!choosePre && cur > 0 && nums[cur - 1] == nums[cur]) {
            return;
        }
        t.add(nums[cur]);
        dfs(true, cur + 1, nums);
        t.remove(t.size() - 1);
    }
}

2.10 491. 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
1 <= nums.length <= 15
-100 <= nums[i] <= 100

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtrack(nums,0);
        return ans;
    }
    private void backtrack(int[] nums,int index){
        if(path.size() > 1){
            ans.add(new ArrayList<>(path));
        }
        int[] used = new int[201];
        for(int i=index;i<nums.length;++i){
            if(!path.isEmpty() && nums[i] < path.get(path.size()-1) || used[nums[i]+100] == 1){
                continue;
            }
            used[nums[i]+100] = 1;
            path.add(nums[i]);
            backtrack(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

2.11 46. 全排列

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。
1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数互不相同

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        backtrack(nums);
        return ans;
    }
    private void backtrack(int[] nums){
        if(path.size() == nums.length){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;++i){
            if(used[i] == true) continue;
            used[i] = true;
            path.add(nums[i]);
            backtrack(nums);
            used[i] = false;
            path.remove(path.size()-1);
        }
    }
}

2.12 47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。
1 <= nums.length <= 8
-10 <= nums[i] <= 10

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new LinkedList<>();
    int[] used;
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new int[nums.length];
        backtrack(nums);
        return ans;
    }
    private void backtrack(int[] nums){
        if(path.size() == nums.length){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;++i){
            if(i>0 && nums[i-1] == nums[i] && used[i-1] == 0) continue;
            if(used[i] == 1) continue;
            used[i] = 1;
            path.add(nums[i]);
            backtrack(nums);
            used[i] = 0;
            path.remove(path.size()-1);
        }
    }
}

2.12 51. N 皇后

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
1 <= n <= 9
皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

class Solution {
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        char[][] chessboard = new char[n][n];
        for (char[] c : chessboard) {
            Arrays.fill(c, '.');
        }
        backTrack(n, 0, chessboard);
        return res;
    }


    public void backTrack(int n, int row, char[][] chessboard) {
        if (row == n) {
            res.add(Array2List(chessboard));
            return;
        }

        for (int col = 0;col < n; ++col) {
            if (isValid (row, col, n, chessboard)) {
                chessboard[row][col] = 'Q';
                backTrack(n, row+1, chessboard);
                chessboard[row][col] = '.';
            }
        }

    }


    public List Array2List(char[][] chessboard) {
        List<String> list = new ArrayList<>();

        for (char[] c : chessboard) {
            list.add(String.copyValueOf(c));
        }
        return list;
    }


    public boolean isValid(int row, int col, int n, char[][] chessboard) {
        // 检查列
        for (int i=0; i<row; ++i) { // 相当于剪枝
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }

        // 检查45度对角线
        for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }

        // 检查135度对角线
        for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
}

2.13 37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
board.length == 9
board[i].length == 9
board[i][j] 是一位数字或者 ‘.’
题目数据保证输入数独仅有一个解

class Solution {
    public void solveSudoku(char[][] board) {
        solveSudokuHelper(board);
    }

    private boolean solveSudokuHelper(char[][] board){
        //「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
        // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
        for (int i = 0; i < 9; i++){ // 遍历行
            for (int j = 0; j < 9; j++){ // 遍历列
                if (board[i][j] != '.'){ // 跳过原始数字
                    continue;
                }
                for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
                    if (isValidSudoku(i, j, k, board)){
                        board[i][j] = k;
                        if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
                            return true;
                        }
                        board[i][j] = '.';
                    }
                }
                // 9个数都试完了，都不行，那么就返回false
                return false;
                // 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
                // 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
            }
        }
        // 遍历完没有返回false，说明找到了合适棋盘位置了
        return true;
    }

    /**
     * 判断棋盘是否合法有如下三个维度:
     *     同行是否重复
     *     同列是否重复
     *     9宫格里是否重复
     */
    private boolean isValidSudoku(int row, int col, char val, char[][] board){
        // 同行是否重复
        for (int i = 0; i < 9; i++){
            if (board[row][i] == val){
                return false;
            }
        }
        // 同列是否重复
        for (int j = 0; j < 9; j++){
            if (board[j][col] == val){
                return false;
            }
        }
        // 9宫格里是否重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++){
            for (int j = startCol; j < startCol + 3; j++){
                if (board[i][j] == val){
                    return false;
                }
            }
        }
        return true;
    }
}