C#八皇后算法：回溯法 vs 列优先法 vs 行优先法 vs 对角线优先法

wenchm2024-03-18 0:08

目录

[1.八皇后算法（Eight Queens Puzzle）](#1.八皇后算法（Eight Queens Puzzle）)

2.常见的八皇后算法解决方案

[（1）列优先法（Column-First Method）：](#（1）列优先法（Column-First Method）：)

[（2）行优先法（Row-First Method）：](#（2）行优先法（Row-First Method）：)

[（3）对角线优先法（Diagonal-First Method）：](#（3）对角线优先法（Diagonal-First Method）：)

（4）回溯法（Backtracking）：

1.八皇后算法（Eight Queens Puzzle）

皇后问题是一个古老而著名的问题，它实质上就是使棋盘上的8个皇后不能在同一行、同一列或同一条斜线上，共有92种方案。

2.常见的八皇后算法解决方案

八皇后算法的解决方案有多种，以下是一些常见的解决方案：

（1）列优先法（Column-First Method）：

八皇后问题是一个经典的回溯算法问题，可以使用列优先法（或称为逐列解决法）来解决。 首先选择一个空的棋盘，然后从第一行开始，尝试将皇后放置在每一列。如果当前列没有被攻击，那么就将皇后放置在该列。否则，尝试下一列。当找到一个有效的列时，将皇后放置在该列的最下方。重复这个过程，直到所有的皇后都被放置在棋盘上。

cs 复制代码 
// 使用列优先法解决八皇后问题
// 列优先算法也叫逐列解决法

namespace _144_4
{
    class Program
    {
        private const int Size = 8;
        private readonly int[] queens = new int[Size];               // 存储每行皇后的列位置
        private readonly bool[] columns = new bool[Size];            // 列是否已被占用
        private readonly bool[] diagonals1 = new bool[2 * Size - 1]; // 主对角线是否已被占用
        private readonly bool[] diagonals2 = new bool[2 * Size - 1]; // 副对角线是否已被占用

        public void Solve()
        {
            PlaceQueen(0);
        }

        int solnum = 0;
        private void PlaceQueen(int row)
        {
            if (row == Size)
            {
                solnum += 1;
                PrintQueens(solnum);  // 所有皇后都已放置，打印结果
                return;
            }

            for (int col = 0; col < Size; col++)
            {
                if (IsSafe(row, col))
                {
                    queens[row] = col;
                    columns[col] = true;
                    diagonals1[row - col + Size - 1] = true;
                    diagonals2[row + col] = true;

                    PlaceQueen(row + 1);

                    // 回溯
                    diagonals2[row + col] = false;
                    diagonals1[row - col + Size - 1] = false;
                    columns[col] = false;
                }
            }
        }

        private bool IsSafe(int row, int col)
        {
            return !columns[col] && !diagonals1[row - col + Size - 1] && !diagonals2[row + col];
        }

        private void PrintQueens(int solnum)
        {
            Console.WriteLine("Solution{0}: ", solnum);
            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    if (queens[i] == j)
                    {
                        Console.Write("Q ");
                    }
                    else
                    {
                        Console.Write("* ");
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        public static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);

            Program solver = new();
            solver.Solve();
        }
    }
}
  • 算法流程

初始化所有数组。

从第一行开始，尝试在每一列放置皇后。

使用回溯法，如果在某一行找不到安全的位置，则返回到上一行并尝试下一个位置。

当所有皇后都成功放置时，打印解决方案。

  • 方法分析

Solve()：启动算法，从第一行开始放置皇后。

PlaceQueen(int row)：递归方法，尝试在当前行的每一列放置皇后。如果找到一个安全的位置，则递归地尝试放置下一个皇后。如果所有皇后都已成功放置，则打印解决方案。

IsSafe(int row, int col)：检查在给定位置 (row, col) 放置皇后是否安全。如果列、主对角线和副对角线都没有被占用，则返回 true。

PrintQueens(int solnum)：打印解决方案。对于每一行，如果当前列有皇后，则打印 "Q"，否则打印 "*"。

（2）行优先法（Row-First Method）：

与列优先法类似，但不同之处在于，该方法从第一列开始，尝试将皇后放置在每一行。如果当前行没有被攻击，那么就将皇后放置在该行的最右侧。否则，尝试下一行。当找到一个有效的行时，将皇后放置在该行的当前列。重复这个过程，直到所有的皇后都被放置在棋盘上。

cs 复制代码 
// 使用行优先法解决八皇后问题
// 行优先算法也叫回溯法
namespace _144_3
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);

            List<int[]> solutions = [];
            int[] solution = new int[8];
            Solve(0, solution, solutions);

            foreach (int[] sol in solutions)
            {
                for (int i = 0; i < 8; i++)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        if (j == sol[i])
                        {
                            Console.Write("Q ");
                        }
                        else
                        {
                            Console.Write(". ");
                        }
                    }
                    Console.WriteLine();
                }
                Console.WriteLine();
            }
        }

        static void Solve(int row, int[] solution, List<int[]> solutions)
        {
            if (row == solution.Length)
            {
                //solutions.Add(solution.ToArray()); // Add a copy of the solution
                solutions.Add([.. solution]);
                return;
            }

            for (int col = 0; col < solution.Length; col++)
            {
                if (IsSafe(row, col, solution))
                {
                    solution[row] = col;
                    Solve(row + 1, solution, solutions);
                }
            }
        }

        static bool IsSafe(int row, int col, int[] solution)
        {
            for (int i = 0; i < row; i++)
            {
                if (solution[i] == col ||
                    Math.Abs(solution[i] - col) == Math.Abs(i - row))
                {
                    return false;
                }
            }
            return true;
        }
    }
}

代码使用了行优先法（也称为回溯法）来解决八皇后问题，这是一个经典的递归回溯问题。 代码分析：

  • Main 方法

Main 方法是程序的入口点。

它首先检查 args 是否为空，如果为空则抛出异常。

初始化一个空列表 solutions 来存储所有解决方案。

调用 Solve 方法来寻找解决方案。

遍历 solutions 列表，并打印出每一个解决方案。

  • Solve 方法

Solve 方法是递归函数，用于寻找八皇后问题的解决方案。

如果当前行 row 等于解决方案数组的长度（即8），则找到一个解决方案，并将其添加到 solutions 列表中。

对于当前行的每一列，检查是否安全（没有冲突），如果安全则在该列放置皇后，并递归调用 Solve 方法处理下一行。

  • IsSafe 方法

IsSafe 方法用于检查在当前位置 (row, col) 放置皇后是否安全。

它遍历已经放置皇后的行，检查当前列和左上方对角线是否有冲突。

如果没有冲突，返回 true；否则返回 false。

  • 注意事项

在 Main 方法中，使用了 ArgumentNullException.ThrowIfNull(args)； 来检查 args 是否为空。这通常用于命令行应用程序，但在没有实际命令行参数需求的程序中是不必要的。

在 Solve 方法中，使用了 solutions.Add([.. solution]); 来添加解决方案的副本到 solutions 列表。这是C# 9.0引入的切片语法，用于创建数组或列表的浅拷贝。用这个简洁的方式来避免直接添加引用到同一个数组。

（3）对角线优先法（Diagonal-First Method）：

该方法首先选择一个空的棋盘，然后从左上角开始，尝试将皇后放置在对角线上。如果当前对角线没有被攻击，那么就将皇后放置在该对角线的最下方。否则，尝试下一个对角线。当找到一个有效的对角线时，将皇后放置在该对角线的当前列。重复这个过程，直到所有的皇后都被放置在棋盘上。

cs 复制代码 
// 八皇后算法_对角线优先法
namespace _144_2
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);

            int n = 8;
            int[] queens = new int[n];
            List<int[]> solutions = [];

            SolveQueens(n, queens, 0, solutions);

            Console.WriteLine("Total solutions: " + solutions.Count);
            foreach (int[] solution in solutions)
            {
                for (int i = 0; i < n; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        if (j == solution[i])
                        {
                            Console.Write("Q ");
                        }
                        else
                        {
                            Console.Write(". ");
                        }
                    }
                    Console.WriteLine();
                }
                Console.WriteLine();
            }
        }

        static void SolveQueens(int n, int[] queens, int index, List<int[]> solutions)
        {
            if (index == n)
            {
                solutions.Add([.. queens]);
                return;
            }

            for (int i = 0; i < n; i++)
            {
                if (CanPlaceQueen(queens, index, i))
                {
                    queens[index] = i;
                    SolveQueens(n, queens, index + 1, solutions);
                }
            }
        }

        static bool CanPlaceQueen(int[] queens, int index, int col)
        {
            for (int i = 0; i < index; i++)
            {
                if (queens[i] == col || Math.Abs(queens[i] - col) == index - i)
                {
                    return false;
                }
            }

            return true;
        }
    }
}

在这个示例中，使用一个整数数组queens来表示棋盘上皇后的位置。queens数组的每个元素表示对应行上皇后的列位置。

使用递归函数SolveQueens来解决八皇后问题。该函数接受当前皇后的位置、当前行号和已找到的解作为参数。在递归过程中，尝试在每一列上放置皇后，并检查是否满足问题的约束条件。如果满足，则将皇后放置在当前行的对应列上，并继续递归处理下一行。如果当前行的所有列都满足约束条件，则表示找到一个解，并将解添加到已找到的解列表中。

函数CanPlaceQueen用于检查在给定位置放置皇后是否满足约束条件。它接受棋盘大小、当前皇后的位置、当前行号和当前列号作为参数。在函数中，遍历当前行号之前的行，检查当前列号是否已经放置了皇后，或者当前行和列上的皇后是否在同一条对角线上。如果满足任一条件，则表示不能在当前位置放置皇后。

在Main函数中，输出找到的解决方案。对于每个解决方案，遍历8行8列，如果当前列是皇后的位置，则输出"Q"，否则输出"."。

（4）回溯法（Backtracking）：

该方法通过递归的方式尝试所有可能的皇后位置。算法步骤如下：

  • 选择一个空的棋盘。
  • 选择一个皇后，将其放置在棋盘的第一行的任意一列。
  • 选择下一个皇后，将其放置在下一行的任意一列，但不能与第一个皇后位于同一列或同一对角线上。
  • 重复步骤3，直到所有的皇后都被放置在棋盘上。
cs 复制代码 
// 八皇后算法_回溯法
namespace _144
{
    class Program
    {
        #region 八皇后算法
        /// <summary>
        /// 解决八皇后问题
        /// </summary>
        /// <param name="size">皇后数量</param>
        static void QueenArithmetic(int size)
        {
            int[] Queen = new int[size];//每行皇后的位置
            int y, x, i, j, d, t = 0;
            y = 0;
            Queen[0] = -1;
            while (true)
            {
                for (x = Queen[y] + 1; x < size; x++)
                {
                    for (i = 0; i < y; i++)
                    {
                        j = Queen[i];
                        d = y - i;
                        //检查新皇后是否能与以前的皇后相互攻击
                        if ((j == x) || (j == x - d) || (j == x + d))
                            break;
                    }
                    if (i >= y)
                        break;     //不攻击
                }
                if (x == size)     //没有合适的位置
                {
                    if (0 == y)
                    {
                        Console.WriteLine("Over");        //回溯到了第一行
                        break;     //结束
                    }
                    Queen[y] = -1; //回溯
                    y--;
                }
                else
                {
                    Queen[y] = x;   //确定皇后的位置
                    y++;            //下一个皇后
                    if (y < size)
                        Queen[y] = -1;
                    else
                    {
                        Console.WriteLine("\n" + ++t + ':');//所有的皇后都排完了，输出
                        for (i = 0; i < size; i++)
                        {
                            for (j = 0; j < size; j++)
                                Console.Write(Queen[i] == j ? 'Q' : '*');
                            Console.WriteLine();
                        }
                        y = size - 1;//回溯
                    }
                }
            }
            Console.ReadLine();
        }
        #endregion

        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);

            int size = 8;           //皇后数
            QueenArithmetic(size);
        }
    }
}
相关推荐
hong_zc1 小时前
算法【Java】—— 二叉树的深搜
java·算法
吱吱鼠叔2 小时前
MATLAB计算与建模常见函数：5.曲线拟合
算法·机器学习·matlab
嵌入式AI的盲3 小时前
数组指针和指针数组
数据结构·算法
Indigo_code5 小时前
【数据结构】【顺序表算法】 删除特定值
数据结构·算法
阿史大杯茶6 小时前
Codeforces Round 976 (Div. 2 ABCDE题)视频讲解
数据结构·c++·算法
LluckyYH6 小时前
代码随想录Day 58|拓扑排序、dijkstra算法精讲，题目:软件构建、参加科学大会
算法·深度优先·动态规划·软件构建·图论·dfs
转调7 小时前
每日一练：地下城游戏
开发语言·c++·算法·leetcode
不穿格子衬衫7 小时前
常用排序算法（下）
c语言·开发语言·数据结构·算法·排序算法·八大排序
wdxylb7 小时前
使用C++的OpenSSL 库实现 AES 加密和解密文件
开发语言·c++·算法
aqua35357423587 小时前
蓝桥杯-财务管理
java·c语言·数据结构·算法
热门推荐
01分享几个惊艳的 Three.js 个人站点02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache