回溯算法探讨

DevDiary

已于 2024-05-18 21:17:28 修改

阅读量668

点赞数 25

分类专栏：算法文章标签：算法回溯算法排列组合 N皇后

于 2024-05-18 19:02:53 首次发布

本文链接：https://blog.csdn.net/www_tlj/article/details/139015193

版权

算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

回溯算法是一种用于寻找所有（或部分）解的算法，特别适用于需要探索所有可能解的组合问题。它通过系统的试错来构建解，并在发现某一步不满足条件时回退到上一步继续尝试其他可能性。回溯算法常用于解决排列、组合、子集生成等问题。

回溯算法的基本思想

回溯算法的基本思想可以概括为以下几点：

选择与尝试：从问题的初始状态开始，选择一个可能的决策，进入下一步状态。
验证与剪枝：在每一步中，检查当前状态是否满足问题的约束条件。如果不满足，则剪枝（即放弃当前路径）。
回退与继续：如果当前状态不能导致最终解，回退到上一步，尝试其他可能的决策。
记录与输出：当找到一个完整的解时，记录并输出解。如果需要所有解，则继续尝试其他路径，直到遍历完所有可能的解。

回溯算法的框架

一个典型的回溯算法可以用伪代码表示如下：

function backtrack(路径, 选择列表):
    if 满足结束条件:
        输出结果
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 新的选择列表)
        撤销选择

其中，“路径”表示已经做出的选择，“选择列表”表示当前可以做出的选择。在每一步中，我们选择一个选项，递归调用函数继续选择，直到满足结束条件。如果发现当前路径不满足条件，就回退到上一步（撤销选择），继续尝试其他可能的选项。

回溯算法的应用

回溯算法适用于很多经典的组合问题，例如：

N皇后问题：在N×N的棋盘上放置N个皇后，使得它们彼此不受攻击。
子集生成：给定一个集合，生成所有可能的子集。
全排列：给定一个序列，生成所有可能的排列。
组合问题：给定一个集合，生成所有可能的组合。
解数独问题：在9×9的数独棋盘上填入数字，使得每行、每列、每个3×3的小格子内的数字不重复。

例子

子集生成

以子集生成为例，展示回溯算法的具体应用。这里用Java语言实现：

import java.util.ArrayList;
import java.util.List;

public class Subsets {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        List<List<Integer>> result = subsets(nums);
        System.out.println(result);
    }

    public static List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), nums, 0);
        return result;
    }

    private static void backtrack(List<List<Integer>> result, List<Integer> tempList, int[] nums, int start) {
        result.add(new ArrayList<>(tempList)); // 记录当前子集
        for (int i = start; i < nums.length; i++) {
            tempList.add(nums[i]); // 做选择
            backtrack(result, tempList, nums, i + 1); // 递归进入下一层
            tempList.remove(tempList.size() - 1); // 撤销选择
        }
    }
}

运行结果：[[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

代码解析

主函数：
- 创建一个数组nums，包含需要生成子集的元素。
- 调用subsets方法，生成所有子集，并将结果打印出来。
subsets方法：
- 创建一个result列表，用于存储所有子集。
- 调用backtrack方法，开始回溯过程。
backtrack方法：
- 将当前的tempList（当前路径）加入到result中。
- 使用一个循环从start位置开始，依次尝试所有可能的选择。
- 在每次选择后，递归调用backtrack，进入下一层。
- 回溯到当前层时，撤销最后一次选择，继续尝试其他可能的选择。

上述示例，简单演示了回溯算法如何通过选择、递归、回退的过程，逐步构建并记录所有可能的解。

全排列

以下是用Java实现的全排列算法：

import java.util.ArrayList;
import java.util.List;

public class Permutations {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        List<List<Integer>> result = permute(nums);
        System.out.println(result);
    }

    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), nums);
        return result;
    }

    private static void backtrack(List<List<Integer>> result, List<Integer> tempList, int[] nums) {
        if (tempList.size() == nums.length) {
            result.add(new ArrayList<>(tempList)); // 记录当前排列
        } else {
            for (int i = 0; i < nums.length; i++) {
                if (tempList.contains(nums[i])) continue; // 如果tempList已经包含nums[i]，跳过
                tempList.add(nums[i]); // 做选择
                backtrack(result, tempList, nums); // 递归进入下一层
                tempList.remove(tempList.size() - 1); // 撤销选择
            }
        }
    }
}

代码解析

permute方法：
- 创建一个result列表，用于存储所有排列结果。
- 调用backtrack方法，开始回溯过程。
backtrack方法：
- 判断当前路径tempList是否等于输入数组的长度，如果是，则将当前排列加入结果列表result。
- 否则，遍历输入数组nums，依次尝试每个元素。
- 如果当前元素已经在tempList中，则跳过（避免重复）。
- 将当前元素加入tempList，递归调用backtrack方法生成后续的排列。
- 递归返回后，撤销最后一次选择，即从tempList中移除最后一个元素，回溯到上一步，继续尝试其他元素。

运行结果

当运行上述代码时，输出结果为：

[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

这表示输入数组{1, 2, 3}的所有可能排列。

示例解释

以输入数组{1, 2, 3}为例：

开始时，tempList 为空。
尝试选择1，tempList 变为 [1]
- 递归进入下一层，选择2，tempList 变为 [1, 2]
  - 递归进入下一层，选择3，tempList 变为 [1, 2, 3]
    - 达到结束条件，记录当前排列[1, 2, 3]
    - 撤销选择3，tempList 变回 [1, 2]
  - 撤销选择2，tempList 变回 [1]
  - 选择3，tempList 变为 [1, 3]
    - 递归进入下一层，选择2，tempList 变为 [1, 3, 2]
      - 达到结束条件，记录当前排列[1, 3, 2]
      - 撤销选择2，tempList 变回 [1, 3]
    - 撤销选择3，tempList 变回 [1]
- 撤销选择1，tempList 变回 []
- 选择2，tempList 变为 [2]
  - 递归进入下一层，选择1，tempList 变为 [2, 1]
    - 递归进入下一层，选择3，tempList 变为 [2, 1, 3]
      - 达到结束条件，记录当前排列[2, 1, 3]
      - 撤销选择3，tempList 变回 [2, 1]
    - 撤销选择1，tempList 变回 [2]
    - 选择3，tempList 变为 [2, 3]
      - 递归进入下一层，选择1，tempList 变为 [2, 3, 1]
        达到结束条件，记录当前排列[2, 3, 1]
        撤销选择1，tempList 变回 [2, 3]
      - 撤销选择3，tempList 变回 [2]
  - 撤销选择2，tempList 变回 []
  - 选择3，tempList 变为 [3]
    - 递归进入下一层，选择1，tempList 变为 [3, 1]
      - 递归进入下一层，选择2，tempList 变为 [3, 1, 2]
        达到结束条件，记录当前排列[3, 1, 2]
        撤销选择2，tempList 变回 [3, 1]
      - 撤销选择1，tempList 变回 [3]
      - 选择2，tempList 变为 [3, 2]
        递归进入下一层，选择1，tempList 变为 [3, 2, 1]
        达到结束条件，记录当前排列[3, 2, 1]
        撤销选择1，tempList 变回 [3, 2]
        撤销选择2，tempList 变回 [3]
    - 撤销选择3，tempList 变回 []

结论

通过回溯算法，我们可以生成所有可能的排列。该算法通过递归尝试每一个元素并回退到之前的状态，确保生成所有可能的组合。

组合问题

我们将实现一个方法，给定一个数组 nums 和一个整数 k，生成所有长度为 k 的组合。

代码实现

import java.util.ArrayList;
import java.util.List;

public class Combinations {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4};
        int k = 2;
        List<List<Integer>> result = combine(nums, k);
        System.out.println(result);
    }

    public static List<List<Integer>> combine(int[] nums, int k) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), nums, k, 0);
        return result;
    }

    private static void backtrack(List<List<Integer>> result, List<Integer> tempList, int[] nums, int k, int start) {
        if (tempList.size() == k) {
            result.add(new ArrayList<>(tempList)); // 记录当前组合
            return;
        }
        for (int i = start; i < nums.length; i++) {
            tempList.add(nums[i]); // 做选择
            backtrack(result, tempList, nums, k, i + 1); // 递归进入下一层
            tempList.remove(tempList.size() - 1); // 撤销选择
        }
    }
}

代码解析

combine方法：
- 创建一个 result 列表，用于存储所有组合结果。
- 调用 backtrack 方法，开始回溯过程。
backtrack方法：
- 判断当前路径 tempList 的长度是否等于 k，如果是，则将当前组合加入结果列表 result。
- 否则，遍历输入数组 nums，依次尝试每个元素，从当前索引 start 开始。
- 将当前元素加入 tempList，递归调用 backtrack 方法生成后续的组合。
- 递归返回后，撤销最后一次选择，即从 tempList 中移除最后一个元素，回溯到上一步，继续尝试其他元素。

运行结果

当运行上述代码时，输出结果为：

[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

这表示输入数组 nums = {1, 2, 3, 4} 中所有长度为 2 的组合。

示例解释

以输入数组 nums = {1, 2, 3, 4} 和 k = 2 为例：

初始调用：

backtrack(result, new ArrayList<>(), nums, k, 0);

第一次递归调用（初始状态：tempList = [], start = 0）：

循环开始，i = 0，选择 1：

tempList.add(1); // tempList = [1]
backtrack(result, tempList, nums, k, 1); // 递归调用，start = 1
tempList.remove(tempList.size() - 1); // 撤销选择，tempList = []

第二次递归调用（状态：tempList = [1], start = 1）：

循环开始，i = 1，选择 2：

tempList.add(2); // tempList = [1, 2]
backtrack(result, tempList, nums, k, 2); // 递归调用，start = 2
tempList.remove(tempList.size() - 1); // 撤销选择，tempList = [1]

第三次递归调用（状态：tempList = [1, 2], start = 2）：
- 记录当前组合 [1, 2]
- 回溯到第二次递归调用，继续执行。
其他递归调用：
- 按上述步骤继续递归、选择和回溯，生成所有长度为 2 的组合。

结论

通过回溯算法，我们可以生成所有可能的组合。该算法通过递归尝试每一个元素并回退到之前的状态，确保生成所有可能的组合。希望这个例子能帮助你理解和实现组合生成算法。

N皇后问题

N皇后问题是经典的组合优化问题，目标是在 𝑁×𝑁 的棋盘上放置 𝑁N 个皇后，使得任何两个皇后都不在同一行、同一列或同一对角线上。我们可以使用回溯算法来解决这个问题。

问题描述

在 𝑁×N 的棋盘上放置 𝑁N 个皇后，使得它们彼此不受攻击。皇后可以攻击同一行、同一列和同一对角线上的其他皇后，因此需要确保任何两个皇后都不在这些位置上。

解决方案

使用回溯算法来生成所有可能的解，并在每一步检查是否满足条件。如果当前解不满足条件，则回退并尝试其他可能的解。

Java实现

下面是解决N皇后问题的Java代码实现：

import java.util.ArrayList;
import java.util.List;

public class NQueens {
    public static void main(String[] args) {
        int n = 8; // 可以改变n的值来解决不同大小的棋盘
        List<List<String>> solutions = solveNQueens(n);
        for (List<String> solution : solutions) {
            for (String row : solution) {
                System.out.println(row);
            }
            System.out.println();
        }
    }

    public static List<List<String>> solveNQueens(int n) {
        List<List<String>> solutions = new ArrayList<>();
        int[] queens = new int[n]; // 索引表示行，值表示皇后所在的列
        backtrack(solutions, queens, n, 0);
        return solutions;
    }

    private static void backtrack(List<List<String>> solutions, int[] queens, int n, int row) {
        if (row == n) {
            solutions.add(generateBoard(queens, n));
            return;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(queens, row, col)) {
                queens[row] = col;
                backtrack(solutions, queens, n, row + 1);
                queens[row] = -1; // 撤销选择
            }
        }
    }

    private static boolean isValid(int[] queens, int row, int col) {
        for (int i = 0; i < row; i++) {
            if (queens[i] == col || Math.abs(queens[i] - col) == Math.abs(i - row)) {
                return false;
            }
        }
        return true;
    }

    private static List<String> generateBoard(int[] queens, int n) {
        List<String> board = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            char[] row = new char[n];
            for (int j = 0; j < n; j++) {
                row[j] = '.';
            }
            row[queens[i]] = 'Q';
            board.add(new String(row));
        }
        return board;
    }
}

代码解析

solveNQueens方法：
- 创建一个 solutions 列表，用于存储所有解。
- 创建一个 queens 数组，索引表示行，值表示皇后所在的列。
- 调用 backtrack 方法，开始回溯过程。
backtrack方法：
- 如果当前行号等于N，表示找到一个解，将其加入 solutions 列表。
- 否则，遍历当前行的每一列，尝试放置皇后。
- 检查当前放置是否有效（不与之前的皇后冲突）。
- 如果有效，将皇后放置在当前位置，并递归调用 backtrack 方法，尝试放置下一行的皇后。
- 递归返回后，撤销当前放置（将当前位置的值设为 -1）。
isValid方法：
- 检查当前放置是否有效。遍历之前的每一行，检查是否与当前放置的皇后冲突。
- 如果在同一列或同一对角线（通过列差与行差相等判断），则返回 false。
generateBoard方法：
- 根据 queens 数组生成棋盘表示。
- 遍历每一行，生成对应的字符串表示，Q 表示皇后，. 表示空位。

运行结果

对于 n = 8，输出结果如下（仅显示部分解）：

.Q......
...Q....
.....Q..
......Q.
.Q......
...Q....
.....Q..
......Q.

每一个解决方案都会在棋盘上正确放置 8 个皇后，且它们彼此不受攻击。

结论

通过回溯算法，我们可以有效地解决N皇后问题。该算法通过递归尝试每一个可能的位置，并在必要时回退，以确保所有可能的解都被生成。

解数独问题

解数独问题是另一个经典的回溯算法应用场景。目标是在一个 9×9 的数独棋盘上填入数字，使得每行、每列、每个 3×3 的小格子内的数字不重复。我们可以使用回溯算法来逐步填充数字，并在发现冲突时回退到上一步继续尝试其他可能的数字。

数独问题描述

给定一个部分填充的 9×9数独棋盘，要求将其完全填充，使得每行、每列和每个 3×3 的小格子中的数字 11 到 99 不重复。

解决方案

使用回溯算法，通过递归尝试每一个位置上的所有可能数字，并在发现冲突时回退（撤销选择），直到找到一个满足条件的解。

Java实现

以下是解决数独问题的Java代码实现：

public class SudokuSolver {
    public static void main(String[] args) {
        char[][] 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'}
        };

        if (solveSudoku(board)) {
            printBoard(board);
        } else {
            System.out.println("No solution exists");
        }
    }

    public static boolean solveSudoku(char[][] board) {
        for (int row = 0; row < 9; row++) {
            for (int col = 0; col < 9; col++) {
                if (board[row][col] == '.') {
                    for (char num = '1'; num <= '9'; num++) {
                        if (isValid(board, row, col, num)) {
                            board[row][col] = num;
                            if (solveSudoku(board)) {
                                return true;
                            }
                            board[row][col] = '.'; // 撤销选择
                        }
                    }
                    return false; // 如果没有有效的数字可以放置，返回false
                }
            }
        }
        return true; // 如果没有空位置，表示已经解决
    }

    private static boolean isValid(char[][] board, int row, int col, char num) {
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == num || board[i][col] == num || 
                board[(row / 3) * 3 + i / 3][(col / 3) * 3 + i % 3] == num) {
                return false;
            }
        }
        return true;
    }

    private static void printBoard(char[][] board) {
        for (int row = 0; row < 9; row++) {
            for (int col = 0; col < 9; col++) {
                System.out.print(board[row][col]);
                if (col < 8) System.out.print(" ");
            }
            System.out.println();
        }
    }
}

代码解析

solveSudoku方法：
- 遍历数独棋盘的每一个位置。
- 如果遇到空位置（即 '.'），尝试填入数字 '1' 到 '9'。
- 检查当前数字是否有效（即不与现有的数字冲突）。
- 如果有效，递归调用 solveSudoku 方法继续尝试填充下一个位置。
- 如果递归成功（即数独已解决），返回 true。
- 如果尝试失败（即没有有效的数字可以放置），撤销当前选择，将该位置恢复为 '.'。
isValid方法：
- 检查在当前行、列和 3×3 小格子中是否存在相同的数字。
- 如果存在相同的数字，返回 false，否则返回 true。
printBoard方法：
- 打印数独棋盘的当前状态。

运行结果

当运行上述代码时，输出结果为：

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

结论

通过回溯算法，我们可以有效地解决数独问题。该算法通过递归尝试每一个可能的位置，并在必要时回退，以确保找到一个满足条件的解。

DevDiary

关注

25
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
回溯算法探讨

回溯算法是一种用于寻找所有（或部分）解的算法，特别适用于需要探索所有可能解的组合问题。它通过系统的试错来构建解，并在发现某一步不满足条件时回退到上一步继续尝试其他可能性。回溯算法常用于解决排列、组合、子集生成等问题。
复制链接

扫一扫