回溯算法的应用

于 2022-11-07 13:01:39 发布
阅读量399 收藏
点赞数
分类专栏： 基本算法 文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42130468/article/details/127729086
版权

模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

1. 组合

题目描述

力扣链接

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

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

代码

class Solution {
    //定义路径
    LinkedList<Integer> path = new LinkedList<>();
    //返回结果
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return res;
    }

     /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
         //设置终止条件：收集完节点就可以
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }

        //回溯中的循环遍历
        for(int i = startIndex;i <= n;i++){
            //加入到路径
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

代码优化（剪枝）

class Solution {
    //定义路径
    LinkedList<Integer> path = new LinkedList<>();
    //返回结果
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return res;
    }

     /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
         //设置终止条件：收集完节点就可以
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }

        //回溯中的循环遍历
        /*  
            此处可以优化，回溯算法的优化大都在控制单层循环的次数上
            n - (k - path.size()) + 1：表示可以向下递归所需的最小剩余数组长度
            例如：n = 4,k = 4
            只有1234，所以当 startIndex = 2,只能遍历到234
         */
        for(int i = startIndex;i <= n - (k - path.size()) + 1;i++){
            //加入到路径
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

2. 组合之和

1. 组合之和（1）

题目描述

力扣链接

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

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

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

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

代码

class Solution {
    //创建结果集
    List<List<Integer>> res = new ArrayList<>();
    //路径
    LinkedList<Integer> path = new LinkedList<>();
    //记录和
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        //创建数组
        int n = candidates.length;
        combinationSumHelp(candidates, target, 0, n);
        return res;
    }

    public void combinationSumHelp(int[] candidates, int target,int startIndex,int n){
        // 减枝
		if (sum > target) {
			return;
		}
        //结束条件
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex;i < n;i++){
            path.add(candidates[i]);
            sum += candidates[i];
            //由于元素可以无限制被取，所以不用i + 1
            combinationSumHelp(candidates, target, i, n);
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

2. 组合之和（2）

题目描述

力扣链接

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

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

注意：解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

代码

class Solution {
    //创建结果集
    List<List<Integer>> res = new ArrayList<>();
    //路径
    LinkedList<Integer> path = new LinkedList<>();
    //记录和
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //创建数组
        int n = candidates.length;
        //为了将重复的数字都放到一起，所以先进行排序
        Arrays.sort(candidates);
        combinationSumHelp(candidates, target, 0, n);
        return res;
    }

    public void combinationSumHelp(int[] candidates, int target,int startIndex,int n){
        // // 减枝
		// if (sum > target) {
		// 	return;
		// }
        //结束条件
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
        //sum + candidates[i] <= target:可以避免单层不必要的遍历，加在这里效率较高，和下面代码效果类似
        /*
        	// // 减枝
            // if (sum > target) {
            // 	return;
            // }
        */
        for(int i = startIndex;i < n && sum + candidates[i] <= target;i++){
            //正确剔除重复解的办法
            //跳过同一树层使用过的元素
            if ( i > startIndex && candidates[i] == candidates[i - 1] ) {
                continue;
            }
            path.add(candidates[i]);
            sum += candidates[i];
            //i + 1：取不同元素
            combinationSumHelp(candidates, target, i + 1, n);
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

3. 组合之和（3）

题目描述

力扣链接

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

代码

class Solution {
     //定义路径
    LinkedList<Integer> path = new LinkedList<>();
    //返回结果
    List<List<Integer>> res = new ArrayList<>();
    //记录和
    int sum = 0;
    public List<List<Integer>> combinationSum3(int k, int n) {
        combineHelper(n, k, 1);
        return res;
    }

     /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        // 减枝
		if (sum > n) {
			return;
		}
         //设置终止条件：收集完节点就可以
        if(path.size() == k){
            if(sum == n)
            res.add(new ArrayList<>(path));
            return;
        }

        //回溯中的循环遍历
        /*  
            此处可以优化，回溯算法的优化大都在控制单层循环的次数上
            n - (k - path.size()) + 1：表示可以向下递归所需的最小剩余数组长度
            例如：n = 4,k = 4
            只有1234，所以当 startIndex = 2,只能遍历到234
         */
        for(int i = startIndex;i <= 9 - (k - path.size()) + 1;i++){
            //加入到路径
            sum += i;
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
            sum -= i;
        }
    }
}

4. 总结

  1. 三种组合之和的回溯代码模板类似
  2. 主要是对求取结果集去重**（去重之前应该先排序）**以及回溯过程剪枝

3. 子集问题

1. 分割回文串

题目描述

力扣链接

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

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

代码

class Solution {
    //结果集
    List<List<String>> res = new ArrayList<>();
    //栈
    Deque<String> stack = new LinkedList<>();
    public List<List<String>> partition(String s) {
        int n = s.length();
        partitionHelp(s, 0, n);
        return res;
    }

    public void partitionHelp(String s,int startIndex,int n){
        //终止条件,如果起始位置大于s的大小，说明找到了一组分割方案
        if(startIndex >= n){
            res.add(new ArrayList<>(stack));
            return;
        }

        //单层循环
        for(int i = startIndex;i < n;i++){
            //判断是不是回文串
            if(isPalindrome(s, startIndex, i)){
                String str = s.substring(startIndex, i + 1);
                stack.addLast(str);
            }else{
                continue;
            }
            //起始位置后移，保证不重复
            partitionHelp(s, i + 1, n);
            stack.removeLast();
        }

    }

    //判断是否是回文串
    private boolean isPalindrome(String s, int startIndex, int end) {
        for (int i = startIndex, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}

2. 复原 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 中的任何数字。你可以按 任何 顺序返回答案。

代码

class Solution {
    //定义路径
    LinkedList<String> stack = new LinkedList<>();
    //返回结果
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    public List<String> restoreIpAddresses(String s) {
        int n = s.length();
        restoreIpAddressesHelp(s, 0, n);
        return res;
    }

     public void restoreIpAddressesHelp(String s,int startIndex,int n){
         
        //终止条件,如果起始位置大于s的大小，说明找到了一组分割方案
        if(startIndex >= n){
            if(stack.size() == 4){
                sb.append(stack.get(0));
                sb.append(".");
                sb.append(stack.get(1));
                sb.append(".");
                sb.append(stack.get(2));
                sb.append(".");
                sb.append(stack.get(3));
                res.add(sb.substring(0, sb.length()));
                sb.delete(0,sb.length());
            }
            return;
        }

        //单层循环
        for(int i = startIndex;i < n && stack.size() <= 4;i++){
            String str = s.substring(startIndex, i + 1);
            //判断数字是不是符合要求
            if(isValid(str)){            
                stack.add(str);
            }else{
                continue;
            }
            //起始位置后移，保证不重复
            restoreIpAddressesHelp(s, i + 1, n);
            stack.removeLast();
        }

    }

    //判断是否是是 0-255
    private boolean isValid(String str) {
        if(str.charAt(0) == '0' && str.length() > 1) return false;
        long num = Long.parseLong(str);
        if(num >= 0 && num <= 255) return true;
        else return false;
    }
}

3. 子集

题目描述

力扣链接

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

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

代码

class Solution {

    List<List<Integer>> res = new ArrayList<>();

    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        //空集是所有集合的子集
        res.add(new ArrayList(0));
        int n = nums.length;
        subsetsHelp(nums, 0, n);
        return res;
    }

    public void subsetsHelp(int[] nums, int startIndex, int n) {
        //终止条件:如果起始位置等于nums的大小，说明找到了一组
        if(path.size() >= n){//终止条件可不加 也可以为 if (startIndex >= nums.length)
            return;
        }
        for(int i = startIndex;i < n;i++){
            path.add(nums[i]);
            res.add(new ArrayList<>(path));
            subsetsHelp(nums, i + 1, n);
            path.removeLast();
        }
    }
}

4. 子集II(去重)

题目描述

力扣链接

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

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

代码

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

    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        //空集是所有集合的子集
        res.add(new ArrayList(0));
        //1. 排序
        Arrays.sort(nums);
        int n = nums.length;
        subsetsWithDupHelp(nums, 0, n);
        return res;
    }

     public void subsetsWithDupHelp(int[] nums, int startIndex, int n) {
        //终止条件:如果起始位置等于nums的大小，说明找到了一组
        if(path.size() >= n){//终止条件可不加 也可以为 if (startIndex >= nums.length)
            return;
        }
        for(int i = startIndex;i < n;i++){
            //2. 去除重复元素
            if ( i > startIndex && nums[i] == nums[i - 1] ) {
                continue;
            }
            path.add(nums[i]);
            res.add(new ArrayList<>(path));
            subsetsWithDupHelp(nums, i + 1, n);
            path.removeLast();
        }
    }
}

4. 全排列

1. 全排列

题目描述

力扣链接

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

代码

class Solution {

    //结果集
    List<List<Integer>> res = new ArrayList<>();
    //路径
    LinkedList<Integer> path = new LinkedList<>();
    //定义访问数组，记录该元素是否被访问
    boolean[] visit;
    public List<List<Integer>> permute(int[] nums) {
        int n = nums.length;
        visit = new boolean[n];
        permuteHelp(nums, n);
        return res;
    }

    public void permuteHelp(int[] nums, int n){
        //返回条件:path中收集了n个元素后返回
        if(path.size() == n){
            res.add(new ArrayList<>(path));
            return;
        }
        
        for(int i = 0;i < n;i++){
            //访问，跳过
            if(visit[i]) continue;
            path.add(nums[i]);
            visit[i] = true;
            //回溯
            permuteHelp(nums, n);
            path.removeLast();
            visit[i] = false;
        }
    }
}

2. 全排列II

题目描述

力扣链接

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

代码

class Solution {

    //结果集
    List<List<Integer>> res = new ArrayList<>();
    //路径
    LinkedList<Integer> path = new LinkedList<>();
    //定义访问数组，记录该元素是否被访问
    boolean[] visit;
    public List<List<Integer>> permuteUnique(int[] nums) {
        int n = nums.length;
        visit = new boolean[n];
        Arrays.fill(visit, false);
        Arrays.sort(nums);
        permuteUniqueHelp(nums, n);
        return res;
    }

    public void permuteUniqueHelp(int[] nums, int n){
        //返回条件:path中收集了n个元素后返回
        if(path.size() == n){
            res.add(new ArrayList<>(path));
            return;
        }
        
        for(int i = 0;i < n;i++){
            // visit[i - 1] == true，说明同⼀树⽀visit[i - 1]使⽤过
            // visit[i - 1] == false，说明同⼀树层visit[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && visit[i - 1] == false) {
                continue;
            }
            //如果同⼀树⽀nums[i]没使⽤过开始处理
            if (visit[i] == false) {
                visit[i] = true;
                path.add(nums[i]);
                //回溯
                permuteUniqueHelp(nums, n);
                path.removeLast();
                visit[i] = false;
            }
        }
	}
}

5. N 皇后问题

题目

题目链接

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

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

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

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

分析

代码

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, '.');
        }
        solveNQueensHelp(n, 0, chessboard);
        return res;  
    }

    public void solveNQueensHelp(int n, int row, char[][] chessboard){
        //结束条件
        if(row == n){
            res.add(Array2List(chessboard));
            return;
        }

        //遍历本层
        for(int j = 0;j < n;j++){
            if(isValid (row, j, n, chessboard)){
                chessboard[row][j] = 'Q';
                solveNQueensHelp(n, row + 1, chessboard);
                chessboard[row][j] = '.';  
            }
        }
    }
    
    //将二维数组转化为List<String> list = new ArrayList<>()
    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;

    }

}

6. 解数独

题目

题目链接

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

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

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

分析

代码

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;
    }
}

参考

代码随想录

0start的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回溯法及其应用
na_beginning的专栏
03-18 2936
参考链接： http://www.cnblogs.com/chinazhangjie/archive/2010/10/22/1858410.html http://baike.baidu.com/link?url=m-I1xz9PSYf9Hr8koWBcx2JNnHVCmKT_wA4L4ryrqHocN-I6oTp-pnEl9HB3FhhT8Gr2J50mG-aNRmF6K5QHbnO3_GdQOF
算法入门6：回溯法
热门推荐
JarvisChu的专栏
11-13 9万+
一. 回溯法 – 深度优先搜素                        1. 简单概述 回溯法思路的简单描述是：把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 基本思想类同于： 图的深度优先搜索二叉树的后序遍历 【 分支限界法：广度优先搜索 思想类同于：图的广度优先遍历 二叉树的层序
回溯法之应用
ChrisChao1992的博客
05-20 236
　　归纳整理如下：回溯法作为一种系统看待被求解问题的策略，适用范围很广，但其算法的时间效率通常很低，因此它常常作为一种启发思路的策略，面对新问题未发现其内在规律时可以首先考虑用回溯法思想全盘的分析，以便逐步发现更好的解决方法。 　　回溯法的应用之一是N皇后问题。问题描述：在国际象棋棋盘上放置N个皇后，要求它们不能相吃。国际象棋中的皇后可以吃掉与它处于同一行、同一列及同一斜角线上的棋子。...
回溯法应用
番茄炒蛋炒饭的博客
11-18 875
问题：设计一个函数，来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径就不能再次进入该格。 解题思路：这是一个回溯法的应用。首先，在矩阵中任选一个格子作为路径的起点，如果矩阵中某个格子的字符为ch，并且这个格子将对应于路径上的第i个字符。如果路径上的第i个字符不是ch，那...
算法分析论文——回溯算法的应用.zip
10-19
总的来说，回溯算法是一种强大的通用求解工具，通过深入研究其原理和应用，我们可以更好地解决实际问题，特别是在面对复杂性和多样性的问题时。对于算法分析来说，理解回溯算法的时间和空间复杂性是至关重要的，这有...
回溯算法设计及其实际应用研究
12-31
回溯算法是一种强大的问题求解方法，广泛应用于解决复杂的问题，如组合优化、搜索和图论等。在计算机科学中，回溯算法通常用于在尝试解决问题时，通过系统地探索可能的解决方案空间来找到有效解。它的工作原理是通过...
PHP实现的回溯算法示例
10-19
回溯算法是一种在解决问题时，通过尝试所有可能的解决方案，并在发现某一步不满足条件时回退到上一步，甚至更早的一步，撤销刚才...在实际应用中，回溯算法常常被用于处理复杂的组合问题，比如图的着色、旅行商问题等。
C++回溯算法实验报告
12-10
总的来说，这个C++实验展示了回溯算法在解决两类问题上的应用，一是利用贪心策略处理具有最优子结构的问题，二是利用深度优先搜索解决非确定性问题。通过实验，学生不仅可以加深对回溯算法的理解，还能提高实际编程...
java回溯算法解数独问题
08-26
在实际应用中，回溯算法可以用于解决其他类型的问题，如八皇后问题、旅行商问题等。 java回溯算法是一种常用的算法，可以用来解决数独问题和其他类型的问题。它的优点是可以快速解决问题，但是缺点是需要大量的计算...
回溯法的简单讲述及应用
05-12
　回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题。
回溯法课件应用原理和回溯法的经典例
05-06
主要是应用原理和回溯法的经典例题等等还有部分经典例题的编写过程等等
回溯算法-》应用
时间轴
07-23 1036
回溯是一种系统地搜索问题解答的方法。为了实现回溯，首先需要为问题定义一个解的空间。而问题的解集合一般被组织成树的形式（一般解所构成树为逻辑树不用去用代码构建一个解集合构成的树）。然后以深度搜索的方式去遍历解集合，从而得到问题的解。可以使用限界函数来避免 对不可能求出解子集合的遍历来优化回溯方法。        回溯方法求解的步骤： 1：定义一个解的空间，它包含问题的解。 2：以适于搜索的方式
五大经典算法之回溯法及其应用
踩踩踩从踩的博客
08-09 2200
前言 回溯法是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”，这就是回溯法的定义；这个和穷举法有些关联，都在不断的试探；而下面从从九宫格、八皇后、数独问题、来理解回溯法 回溯法的应用 九宫格问题 我们要将4或者9个数或者16个数 n的n次方个数放入九宫格中，使得所有斜线和直线的数相加都等于相同的值，怎么解决这个问题；这就...
回溯算法的经典应用 —— LeetCode 51.N皇后问题（Kotlin）
Alpinist Wang
03-07 472
回溯算法基于深度优先搜索算法。N皇后问题很好的体现了回溯算法的思想。
【回溯算法得一些应用】数据结构与算法
小孙的博客
02-12 491
回溯算法实际上是一个类似穷举的的搜索尝试过程，主要是在搜索尝试过程中寻找问题的阶，当发现已不满足求解条件时就“回溯”（即回退），尝试其他路径，所以回溯法有“通常的解题法”之称。 从一条路往前走，能进则进，不能进则退回来，换一条路再试试。 ...
[学习记录]回溯算法及其应用
qq_57886603的博客
03-06 1294
目录 一、简介 二、回溯算法的应用 三、回溯算法的模板 四、回溯算法解决子集问题 (一)子集问题描述 (二)问题解决 (三)代码实现 (四)剪枝操作 五、回溯算法解决分割问题 一、简介 回溯与递归是相辅相成的，有回溯的地方必然会使用到递归。回溯算法并非是一种高效的算法，而是一种暴力法。 二、回溯算法的应用 对于某些问题来说，即便多层for循环也无法解决，也无法写出这种程序，这时候就需...
回溯算法经典应用之—N皇后问题 (Java)
qianhaifeng2012的博客
08-24 4370
1、回溯算法简介 回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。用回溯算法解决问题的一般步骤为： 1、定义一个解空间，它包含问题的解。 2、利用适于搜索的方法组织解空间。 3、利用深度优先法搜索解空间。 4、利用限界函数避免移动到不可能产生解的子空间。 问题的解空间通常是在搜索问题的解的过程中动态产生
回溯算法理论及应用
qq_41721746的博客
03-19 1754
一. 回溯算法基础理论 二. 子集树 1. 输出所有的子集 2. 整数选择问题求解 3. 2N整数选择问题 4. 挑数字问题 (1) 使用子集树解决 (2) 使用枚举法解决 三. 排列数 1. 0-1背包问题 2. 排列树理论及代码实现 3. 八皇后问题求解 4. 基于穷举法的全排列实现
回溯算法的刷题笔记，回溯专训
04-03
在实际应用中，回溯算法经常用于解决全排列、N皇后问题、组合总数等。通过深入理解回溯算法的思想和实现方式，我们可以掌握解决这些问题的方法，提高编程能力。 总而言之，回溯算法是一种经典的解决问题的方法。它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值