力扣技巧-回溯

原创 已于 2022-09-09 23:24:43 修改 · 252 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #深度优先 #算法

于 2022-09-06 18:34:12 首次发布
这篇博客详细解析了如何使用回溯算法解决LeetCode上的多个经典问题，包括N皇后、全排列、解数独、括号生成等，并提供了题解，最后总结了在哪些情况下不需要使用回溯算法。
51. N 皇后

题解：

class Solution {
    private int n;
    private boolean[] col;
    private boolean[] master;
    private boolean[] slave;
    private List<List<String>> res;
    public List<List<String>> solveNQueens(int n) {
        this.n = n;
        col = new boolean[n];
        master = new boolean[2 * n - 1];
        slave = new boolean[2 * n - 1];
        res = new ArrayList<>();
        Deque<Integer> stack = new ArrayDeque<>();
        dfs(0, stack);
        return res;
    }
    private void dfs(int row, Deque<Integer> stack) {
        if (row == n) {
            List<String> board = covert2Board(stack, n);
            res.add(board);
            return;
        }
        for (int i = 0; i < n; i ++) {
            if (!col[i] && !master[row + i] && !slave[row - i + n - 1]) {
                stack.addLast(i);
                col[i] = true;
                master[row + i] = true;
                slave[row - i + n - 1] = true;
                dfs(row + 1, stack);
                col[i] = false;
                master[row + i] = false;
                slave[row - i + n - 1] = false;
                stack.removeLast();
            }
        }
    }
    // 保存一个结果的stack，皇后数量：n
    private List<String> covert2Board(Deque<Integer> stack, int n) {
        List<String> board = new ArrayList<>();
        for (Integer num : stack) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; i ++) {
                sb.append(".");
            }
            sb.replace(num, num + 1, "Q");
            board.add(sb.toString());
        }
        return board;
    }
}
46. 全排列

题解：

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        Deque<Integer> path = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        dfs(nums, -1, visited, path, res);
        return res;
    }

    private void dfs(int[] nums, int index, boolean[] visited, Deque<Integer> path, List<List<Integer>> res) {
        final int n = nums.length;
        if (path.size() == n) {
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = 0; i < n; i ++) {
            if (visited[i]) {
                continue;
            }
            path.addLast(nums[i]);
            visited[i] = true;
            dfs(nums, i, visited, path, res);
            visited[i] = false;
            path.removeLast();
        }
    }
}
47. 全排列 II

题解：

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        Deque<Integer> path = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        Arrays.sort(nums);
        dfs(nums, 0, path, visited, res);
        return res;
    }

    private void dfs(int[] nums, int len, Deque<Integer> path, boolean[] visited, List<List<Integer>> res) {

        final int n = nums.length;
        if (len == n) {
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = 0; i < n; i ++) {
            if (visited[i]) {
                continue;
            }
            if (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
                continue;
            }
            path.addLast(nums[i]);
            visited[i] = true;
            dfs(nums, len + 1, path, visited, res);
            visited[i] = false;
            path.removeLast();
        }

    }
}
37. 解数独

题解：

class Solution {

    private int m;
    private int n;
    private boolean[][] rows;
    private boolean[][] cols;
    private boolean[][] blocks;

    public void solveSudoku(char[][] board) {
        this.m = board.length;
        this.n = board[0].length;
        rows = new boolean[9][10];
        cols = new boolean[9][10];
        blocks = new boolean[9][10];
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if ('.' != board[i][j]) {
                    char number = board[i][j];
                    rows[i][number - '0'] = true;
                    cols[j][number - '0'] = true;
                    blocks[blockIndex(i, j)][number - '0'] = true;
                }
            }
        }
        dfs(board, 0);
    }

    private boolean dfs(char[][] board, int depth) {

        if (depth == 81) {
            return true;
        }

        int row = rowIndex(depth);
        int col = colIndex(depth);

        if ('.' != board[row][col]) {
            return dfs(board, depth + 1);
        }

        for (int i = 1; i < 10; i ++) {
            if (rows[row][i] || cols[col][i] || blocks[blockIndex(row, col)][i]) {
                continue;
            }
            board[row][col] = (char)(i + '0');
            rows[row][i] = true;
            cols[col][i] = true;
            blocks[blockIndex(row, col)][i] = true;
            if (dfs(board, depth + 1)) {
                return true;
            }
            rows[row][i] = false;
            cols[col][i] = false;
            blocks[blockIndex(row, col)][i] = false;
            board[row][col] = '.';
        }

        return false;
    }

    private int rowIndex(int depth) {
        return depth / 9;
    }

    private int colIndex(int depth) {
        return depth % 9;
    }

    private int blockIndex(int i, int j) {
        return i / 3 * 3 + j / 3;
    }
}
22. 括号生成

题解：

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        dfs("", res, 0, 0, n);
        return res;
    }

    private void dfs(String s, List<String> res, int num, int index, int n) {

        if (num > n || index > 2 * n) {
            return;
        }

        if (index == 2 * n && num == n) {
            if (checkParenthesis(s)) {
                res.add(s);
            }
            return;
        }

        dfs(s + "(", res, num + 1, index + 1, n);
        dfs(s + ")", res, num, index + 1, n);
    }

    private boolean checkParenthesis(String s) {

        final int n = s.length();
        if (0 != (n % 2)) {
            return false;
        }

        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < n; i ++) {
            char c = s.charAt(i);
            if ('(' == c) {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                stack.pop();
            }
        }

        return stack.isEmpty();
    }
}
17. 电话号码的字母组合

题解：

class Solution {

    private String[] strs = new String[]{
        "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"
    };

    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList<>();
        if (null == digits || "".equals(digits)) {
            return res;
        }
        dfs("", 0, digits, res);
        return res;
    }

    private void dfs(String s, int depth, String digits, List<String> res) {

        final int n = digits.length();
        if (depth == n) {
            res.add(s);
            return;
        }
        
        String str = strs[digits.charAt(depth) - '0'];
        for (int i = 0; i < str.length(); i ++) {
            char c = str.charAt(i);
            dfs(s + c, depth + 1, digits, res);
        }
    }
}
39. 组合总和

题解：

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<Integer> path = new LinkedList<>();
        dfs(candidates, target, 0, 0, path, res);
        return res;
    }

    private void dfs(int[] candidates, int target, int index, int sum, Deque<Integer> path, List<List<Integer>> res) {
        final int n = candidates.length;

        if (sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }

        if (sum > target) {
            return;
        }

        for (int i = index; i < n; i ++) {
            path.addLast(candidates[i]);
            dfs(candidates, target, i, sum + candidates[i], path, res);
            path.removeLast();
        }
    }
}
40. 组合总和 II

题解：

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<Integer> path = new ArrayDeque<>();
        boolean[] visited = new boolean[candidates.length];
        Arrays.sort(candidates);
        dfs(candidates, 0, visited, -1, target, path, res);
        return res;
    }

    private void dfs(int[] candidates, int sum, boolean[] visited, int index, int target, Deque<Integer> path, List<List<Integer>> res) {

        if (sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }

        if (sum > target) {
            return;
        }

        for (int i = index + 1; i < candidates.length; i ++) {

            if (i > 0 && candidates[i] == candidates[i - 1] && !visited[i - 1]) {
                continue;
            }

            path.addLast(candidates[i]);
            visited[i] = true;
            dfs(candidates, sum + candidates[i], visited, i, target, path, res);
            visited[i] = false;
            path.removeLast();
        }
    }
}
216. 组合总和 III

题解：

class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        Deque<Integer> path = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        dfs(0, 0, 0, k, n, path, res);
        return res;
    }

    private void dfs(int index, int num, int sum, int k, int n, Deque<Integer> path, List<List<Integer>> res) {

        if (num == k && sum == n) {
            res.add(new ArrayList<>(path));
            return;
        }

        if (num > k || sum > n) {
            return;
        }

        for (int i = index + 1; i < 10; i ++) {
            path.addLast(i);
            dfs(i, num + 1, sum + i, k, n, path, res);
            path.removeLast();
        }
    }
}
78. 子集

题解：

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        Deque<Integer> path = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();
        dfs(nums, -1, path, res);
        return res;
    }

    private void dfs(int[] nums, int index, Deque<Integer> path, List<List<Integer>> res) {

        res.add(new ArrayList<>(path));

        for (int i = index + 1; i < nums.length; i ++) {
            path.addLast(nums[i]);
            dfs(nums, i, path, res);
            path.removeLast();
        }
    }
 }
90. 子集 II

题解：

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Deque<Integer> path = new ArrayDeque<>();
        Arrays.sort(nums);
        boolean[] visited = new boolean[nums.length];
        dfs(nums, -1, visited, path, res);
        return res;
    }

    private void dfs(int[] nums, int index, boolean[] visited, Deque<Integer> path, List<List<Integer>> res) {

        res.add(new ArrayList<>(path));

        for (int i = index + 1; i < nums.length; i ++) {
            
            if (visited[i]) {
                continue;
            }

            if (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
                continue;
            }

            visited[i] = true;
            path.addLast(nums[i]);
            dfs(nums, i, visited, path, res);
            path.removeLast();
            visited[i] = false;
        }
    }
}
1593. 拆分字符串使唯一子字符串的数目最大

题解：

class Solution {

    private int res = 1;

    public int maxUniqueSplit(String s) {
        Set<String> visited = new HashSet<>();
        dfs(s, 0, visited);
        return res;
    }

    private void dfs(String s, int sum, Set<String> visited) {

        final int n = s.length();

        if (0 == n) {
            res = Math.max(res, sum);
            return;
        }

        for (int i = 1; i <= n; i ++) {
            String preStr = s.substring(0, i);
            String postStr = s.substring(i, n);
            if (visited.contains(preStr)) {
                continue;
            }
            visited.add(preStr);
            dfs(postStr, sum + 1, visited);
            visited.remove(preStr);
        }
    }


}
79. 单词搜索

题解：

class Solution {

    private int[][] directions = new int[][]{
        {-1, 0}, {0, 1}, {1, 0}, {0, -1}
    };
    private int m;
    private int n;

    public boolean exist(char[][] board, String word) {
        m = board.length;
        n = board[0].length;
        boolean[][] visited = new boolean[m][n];
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                visited[i][j] = true;
                if (dfs(board, i, j, visited, word, 0)) {
                    return true;
                }
                visited[i][j] = false;    
            }
        }
        return false;
    }

    private boolean dfs(char[][] board, int row, int col, boolean[][] visited, String word, int index) {
        
        if (board[row][col] != word.charAt(index)) {
            return false;
        }

        final int len = word.length();
        if (index == len - 1) {
            return true;
        }


        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y]) {
                continue;
            }
            visited[x][y] = true;
            if (dfs(board, x, y, visited, word, index + 1)) {
                return true;
            }
            visited[x][y] = false;
        }

        return false;
    }
}
695. 岛屿的最大面积

题解：

class Solution {

    private int m;
    private int n;
    private int[][] directions = new int[][]{
        {-1, 0}, {1, 0}, {0, 1}, {0, -1}
    };
    private int res;
    private Integer sum;

    public int maxAreaOfIsland(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        res = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (1 == grid[i][j]) {
                    sum = 1;
                    visited[i][j] = true;
                    dfs(grid, i, j, visited);
                    visited[i][j] = false;
                }
            }
        }

        return res;
    }

    private void dfs(int[][] grid, int row, int col, boolean[][] visited) {
        res = Math.max(res, sum);

        grid[row][col] = 0;

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y] || 0 == grid[x][y]) {
                continue;
            }
            visited[x][y] = true;
            sum ++;
            dfs(grid, x, y, visited);
            visited[x][y] = false;
        }
    }


}
417. 太平洋大西洋水流问题

题解：

class Solution {

    private int m;
    private int n;
    private int[][] directions = new int[][]{
        {-1, 0}, {1, 0}, {0, -1}, {0, 1}
    };

    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        m = heights.length;
        n = heights[0].length;
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                boolean[][] visited = new boolean[m][n];
                visited[i][j] = true;
                if (pacificDfs(heights, i, j, visited) && atlanticDfs(heights, i, j, visited)) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    list.add(j);
                    res.add(list);
                }
                visited[i][j] = false;
            }
        }

        return res;
    }

    private boolean pacificDfs(int[][] heights, int row, int col, boolean[][] visited) {

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || y < 0) {
                return true;
            }
            if (x >= m || y >= n || visited[x][y] || heights[x][y] > heights[row][col]) {
                continue;
            }
            visited[x][y] = true;
            boolean flag = pacificDfs(heights, x, y, visited);
            visited[x][y] = false;
            if (flag) {
                return true;
            }
        }

        return false;
    }

    private boolean atlanticDfs(int[][] heights, int row, int col, boolean[][] visited) {

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x >= m || y >= n) {
                return true;
            }
            if (x < 0 || y < 0 || visited[x][y] || heights[x][y] > heights[row][col]) {
                continue;
            }
            visited[x][y] = true;
            boolean flag = atlanticDfs(heights, x, y, visited);
            visited[x][y] = false;
            if (flag) {
                return true;
            }
        }

        return false;
    }


}
1020. 飞地的数量

题解：

class Solution {

    private int m;
    private int n;
    private int[][] directions = new int[][]{
        {-1, 0}, {1, 0}, {0, -1}, {0, 1} 
    };

    public int numEnclaves(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if ((0 == i || (m - 1 == i) || 0 == j || (n - 1 == j)) && (1 == grid[i][j])) {
                    dfs(grid, i, j, visited);
                }
            }
        }

        int sum = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (1 == grid[i][j]) {
                    sum ++;
                }
            }
        }

        return sum;
    }

    private void dfs(int[][] grid, int row, int col, boolean[][] visited) {

        grid[row][col] = 0;

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y] || 0 == grid[x][y]) {
                continue;
            } 
            visited[x][y] = true;
            dfs(grid, x, y, visited);
            visited[x][y] = false;
        }
    }
}
1254. 统计封闭岛屿的数目

题解：

class Solution {

    private int m;
    private int n;
    private int[][] directions = new int[][]{
        {-1, 0}, {0, -1}, {1, 0}, {0, 1}
    };

    public int closedIsland(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if ((0 == i || (m - 1 == i) || 0 == j || (n - 1 == j)) && 0 == grid[i][j]) {
                    visited[i][j] = true;
                    dfs(grid, i, j, visited);
                    visited[i][j] = false;
                }
            }
        }

        int res = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (0 == grid[i][j]) {
                    res ++;
                    visited[i][j] = true;
                    dfs(grid, i, j, visited);
                    visited[i][j] = false;
                }
            }
        }

        return res;
    }

    private void dfs(int[][] grid, int row, int col, boolean[][] visited) {

        grid[row][col] = 1;

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y] || 1 == grid[x][y]) {
                continue;
            }
            visited[x][y] = true;
            dfs(grid, x, y, visited);
            visited[x][y] = false;
        }
    }
}
面试题13. 机器人的运动范围

总结：不需要回溯
题解：

class Solution {

    private int[][] directions = new int[][]{
        {-1, 0}, {1, 0}, {0, -1}, {0, 1}
    };
    private int res = 0;

    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        visited[0][0] = true;
        dfs(0, 0, m, n, k, visited);
        return res;
    }

    private void dfs(int row, int col, int m, int n, int k, boolean[][] visited) {

        if (checkNumber(row) + checkNumber(col) > k) {
            return;
        }

        res ++;

        for (int d = 0; d < directions.length; d ++) {
            int x = row + directions[d][0];
            int y = col + directions[d][1];
            if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y]) {
                continue;
            }
            visited[x][y] = true;
            dfs(x, y, m, n, k, visited);
        }
    }

    private int checkNumber(int number) {
        int sum = 0;
        while (number > 0) {
            sum += (number % 10);
            number = number / 10;
        }
        return sum;
    }
}
力扣---戳气球
wolfGuiDao的博客
05-09 1004
戳气球 文章目录戳气球一、题目描述二、回溯思路三、动态规划思路四、代码 一、题目描述 有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。 现在要求你戳破所有的气球。每当你戳破一个气球 i 时，你可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。 求所能获得硬币的最大数量。
力扣--目标和
wolfGuiDao的博客
07-01 1868
力扣–目标和 文章目录力扣--目标和一、题目描述二、分析方法一：回溯方法二、消除重叠子问题方法三、动态规划 一、题目描述 class Solution { public: int findTargetSumWays(vector<int>& nums, int S) { } }; 二、分析 方法一：回溯 任何算法的核心都是穷举，回溯算法就是一个暴力穷举算法，回溯算法框架： def backtrack(路径, 选择列表): if 满足结束条件:
力扣刷题笔记——回溯
qq_53633989的博客
05-17 565
本文为代码随想录的学习笔记捏，可自行搜索公众号学习回溯是一种暴力搜索的算法，可解决以下问题：为什么是暴力搜索呢，因为这个方法的思想就是列举全部可能的结果，从中取出符合题目要求的结果。所以说，回溯不高效，并不高效但不代表没用，对于有的问题我们也只能使用回溯解决。回溯是递归的副产品，只要有递归就会有回溯，回溯的本质为穷举，集合的大小做题公式如下。
力扣-回溯法
weixin_63551790的博客
07-12 1162
对于回溯法，首先找到边界条件以及结束的条件。一般为设置的i等于行数。边界条件一般为不要越界。一般还需要设置标记函数。然后一行一行进行访问或者一个位置一个位置的访问，访问过的标记函数置为true。接着继续下一个或者下一行（一般是递归）。然后结束后还原上面的标记函数以及board（一般会设置一个作为答案）。符合的就push_back到ans数组中去。
回溯-力扣-java
a716121的专栏
05-24 228
class Solution { 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(board,words,i,j,0)...
力扣LeetCode-回溯法
weixin_56005963的博客
02-16 719
回溯法 基本知识 1. 思想 穷举所有可能，选出想要的答案。 2. 解决的问题 组合问题：N个数中按一定规则找出k个数的集合； 切割问题：一个字符串按一定规则有几种切割方式； 子集问题：一个N个数的集合中有多少符合条件的子集； 排列问题：N个数按一定规则全排列，有几种排列方式； 棋盘问题：N皇后，解数独； 3. 模板 void backtracking(参数){ if(终止条件){ 存放结果; return...
力扣题型总汇——回溯算法
qq_51329170的博客
03-21 1093
回溯算法总结： 题目： Day59:77组合
代码随想录-力扣刷题-总结笔记02
upward
04-04 1403
代码随想录-力扣刷题-总结笔记02
力扣-LeetCode全套2000题目解答C++和Java版.rar
06-26
力扣(LeetCode)是一个非常受欢迎的在线编程挑战平台，旨在提升程序员的算法技能和问题解决能力。这个压缩包文件包含的是LeetCode上2000道编程题目的C++和Java解法，覆盖了从第1题到第2000题的广泛范围。这些题目涵盖...
掌握力扣刷题技巧：回溯算法详解与应用
力扣训练是指程序员通过在力扣平台上完成编程题目来锻炼和提升自己的编程技巧，特别是在算法设计方面的能力。通过持续的练习，程序员可以加深对各种算法的理解，学会在实际编程中灵活应用这些算法，同时也能提高解决...
【回溯算法】-力扣总结
嗑盐工作室
12-31 456
回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法。适用于求解组合数较大...
力扣刷题记录_回溯算法
qq_43563660的博客
02-17 988
记录力扣回溯算法解题题目
力扣-回溯法技巧总结
qq_21717739的博客
03-02 459
力扣回溯法技巧总结 排列/组合/子集问题的三种形式在代码上的区别。 由于子集问题和组合问题本质上是一样的，无非就是 base case 有一些区别，所以把这两个问题放在一起看。 形式一、元素无重不可复选，即nums中的元素都是唯一的，每个元素最多只能被使用一次，backtrack核心代码如下： /* 组合/子集问题回溯算法框架 */ void backtrack(int[] nums, int start) { // 回溯算法标准框架 for (int i = start; i < nums.leng
力扣热题之回溯
最新发布
m0_74033390的博客
08-14 232
本文总结了回溯算法的核心知识点和力扣真题解法。回溯三部曲包括：1)确定函数参数（排列用used数组，组合用startIndex）；2)终止条件（path大小等于nums大小）；3)单层递归逻辑（组合从下节点开始，排列从头开始）。通过9道真题（全排列、子集、IP地址复原、电话号码组合、组合总和、括号生成、单词搜索、分割回文串、N皇后问题），详细分析了回溯实现中的关键点：参数传递、结果收集、状态恢复、剪枝条件等。特别强调排列与组合的区别、索引控制、路径回溯等易错点，并建议通过重复练习加深理解。
力扣题之回溯算法
qq_44807946的博客
05-19 313
回溯算法，更新中......
力扣专题. 回溯法
爱学习i的博客
10-06 660
1. 回溯法与深度遍历的联系以及不同点： 回溯法采用试错的思想，它尝试分步的去解决一个问题。当它发现分步的答案不能得到有效的解决时就会退回上一步甚至上几步。回溯法通常用递归的方法来解决。 深度遍历是树的一种遍历方法，它强调的是一头扎到底然后再往回走的途中去遍历其它结点，这个过程会一直持续到初始的根结点。 2.回溯法与动态规划的区别和共同点： 共同点： 一个问题都能够分为很多步骤来解决； 每一个步骤包含了很多种选择； 不同点： 动态规划强调的是问题的最优解，它只需要知道最终的结果； 回溯可以搜索到问
力扣3——回溯算法
m0_38057941的博客
03-27 450
1.回溯算法的框架 1.1.解决一个回溯问题，实际上就是一个决策树的遍历过程，只需要思考3个问题 1.路径：就是已经做出的选择； 2.选择列表：也就是你当前可以做的选择； 3.结束条件：也就是到达决策树底层，无法再做出选择的条件。 1.2.代码框架 result = [] def backtrack(路径，选择列表)： if 满足结束条件“ result.add(路径) return； for 选择 in 选择列表： 做选择； backtrack(路径，选择列表)； 撤销选择；
力扣做题思路--回溯算法
weixin_55435895的博客
03-24 307
回溯算法解决一些神奇的排列组合问题有奇效，我是在看到括号生成问题的力扣解答才发现这个神奇的算法。 力扣，这题比较一个容易理解的就是回溯算法，题目中有题解从第一个括号出发，然后需要保持括号的有效性。 方法如下 def dfs(self, res, left, right , path): # path 就是路径，left是左边括号还剩下多少 if left == 0 and right == 0: res.append(path) return
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值