探究八皇后问题的递归与非递归解法

引言

八皇后问题是一个经典的计算机科学问题，涉及在8x8的棋盘上放置八个皇后，使得它们彼此之间无法相互攻击。这个问题可以通过递归和非递归两种方法来解决，本文将详细介绍八皇后问题的规则、递归解法和非递归解法，并提供C++代码实现。

一、八皇后问题的规则

八皇后问题的目标是在一个8x8的棋盘上放置八个皇后，使得每个皇后都不会互相攻击。皇后可以水平、垂直或对角线移动，因此不能在同一行、同一列或同一对角线上放置两个皇后。八皇后问题的解决方案要求在棋盘上找到合法的位置布局。

二、递归解法

递归是解决八皇后问题最常用的方法之一。下面是八皇后问题的递归解法步骤：

1. 设计一个辅助函数来处理每一行的皇后放置。
2. 对于每一行，遍历所有列，尝试将皇后放置在当前位置。
3. 如果当前位置与之前放置的皇后位置冲突（同一列或同一对角线），则回溯到上一行并尝试下一个位置。
4. 如果所有列都尝试过后仍然无法放置皇后，则回溯到上一行并继续尝试下一个位置。
5. 当放置的皇后数量达到八个时，找到了一种合法的解决方案。

通过递归调用上述辅助函数，并在找到八个皇后的合法布局时打印出结果，我们可以完成整个八皇后问题的解决。下面是使用C++实现递归解法的示例代码：

#include <iostream>
#include <vector>

void solveNQueensRecursive(std::vector<int>& queens, int row, std::vector<std::vector<std::string>>& result) {
    int n = queens.size();

    if (row == n) {
        std::vector<std::string> solution;
        for (int i = 0; i < n; i++) {
            std::string rowStr(n, '.');
            rowStr[queens[i]] = 'Q';
            solution.push_back(rowStr);
        }
        result.push_back(solution);
        return;
    }

    for (int col = 0; col < n; col++) {
        bool canPlace = true;
        for (int i = 0; i < row; i++) {
            if (queens[i] == col || queens[i] == col + row - i || queens[i] == col - row + i) {
                canPlace = false;
                break;
            }
        }
        if (canPlace) {
            queens[row] = col;
            solveNQueensRecursive(queens, row + 1, result);
        }
    }
}

std::vector<std::vector<std::string>> solveNQueens(int n) {
    std::vector<int> queens(n, -1);
    std::vector<std::vector<std::string>> result;
    solveNQueensRecursive(queens, 0, result);
    return result;
}

int main() {
    int n = 8;
    std::vector<std::vector<std::string>> result = solveNQueens(n);

    for (const auto& solution : result) {
        for (const auto& row : solution) {
            std::cout << row << std::endl;
        }
        std::cout << std::endl;
    }

    return 0;
}

以上代码实现了递归解法，并通过一个整数数组queens来表示皇后的位置，使用.表示空格，使用Q表示皇后。程序将打印出所有合法的八皇后布局。

三、非递归解法

除了递归解法外，我们还可以使用非递归方式解决八皇后问题。下面是一种基于栈的非递归解法思路：

1. 创建一个空栈和一个整数数组queens来存储每一行皇后的位置。
2. 遍历第一行的所有列，并将皇后的位置入栈。
3. 进入循环，重复以下步骤：
   • 如果栈的大小等于八，找到一种合法的解决方案，将皇后位置添加到结果中。
   • 如果皇后位置数组的最后一个值大于等于七（即列数达到七），则回溯到上一行并尝试下一个位置。
   • 否则，从当前位置的下一列开始，遍历所有列并将新的皇后位置入栈。
4. 输出结果。

通过循环和栈的操作来模拟递归过程，我们可以得到非递归解法。下面是使用C++实现非递归解法的示例代码：

#include <iostream>
#include <vector>
#include <stack>

struct Queen {
    int row;
    int col;

    Queen(int r, int c) : row(r), col(c) {}
};

std::vector<std::vector<std::string>> solveNQueens(int n) {
    std::vector<std::vector<std::string>> result;
    std::stack<Queen> stack;
    std::vector<int> queens(n, -1);

    int row = 0;
    int col = 0;

    while (row < n) {
        if (col >= n) {
            if (stack.empty()) {
                break;
            }
            Queen lastQueen = stack.top();
            stack.pop();
            queens[lastQueen.row] = -1;
            row = lastQueen.row;
            col = lastQueen.col + 1;
            continue;
        }

        bool canPlace = true;
        for (int i = 0; i < row; i++) {
            if (queens[i] == col || queens[i] == col + row - i || queens[i] == col - row + i) {
                canPlace = false;
                break;
            }
        }

        if (canPlace) {
            queens[row] = col;
            stack.push(Queen(row, col));

            if (row == n - 1) {
                std::vector<std::string> solution;
                for (int i = 0; i < n; i++) {
                    std::string rowStr(n, '.');
                    rowStr[queens[i]] = 'Q';
                    solution.push_back(rowStr);
                }
                result.push_back(solution);
            }

            row++;
            col = 0;
        }
        else {
            col++;
        }
    }

    return result;
}

int main() {
    int n = 8;
    std::vector<std::vector<std::string>> result = solveNQueens(n);

    for (const auto& solution : result) {
        for (const auto& row : solution) {
            std::cout << row << std::endl;
        }
        std::cout << std::endl;
    }

    return 0;
}

以上代码实现了非递归解法，并通过一个整数数组queens来表示。

结论

emm...这篇文章就没结论了哈。还望大佬们三连支持一下。