运用全排列的方法解决八皇后问题

运用全排列的方法解决八皇后问题，可以分为两部分：全排列和八皇后，下面我将分开说明两个步骤。

首先说明八皇后：

第一步：就是把皇后按照0到8编号，然后对八个皇后进行全排列，一共有40320种排列方式。

第二步：将全排列的40320种排列结果进行筛选，选出满足八皇后问题的结果，共有92种结果。

先说一下，为什么好像只用的一个数组，怎么就解决了一个二维的问题。其实全排列的方法是用了两个一维数组。

1、用0到7八个序号（下面用i,j表示），把他看成棋盘的X轴i，j不可能相同，所以不同列。

2、ColumnIndex[]中的不可能有相同值，所以不同行。

3、行、列都解决的，接下来看对角。通过观察可以知道，如果两个棋盘格子处在对角的位置，那么他们的横坐标之差等于他们的纵坐标之差（或者相反数）。

4、遍历全排列结果，如果不满足第三点（因为前两点是for循环控制的），就返回false，即不是八皇后的答案；

//ColumnIndex[]里面装的是皇后的一次全排列的排列数，因为是全排列的结果，所以可以将其看作皇后的纵坐标（将它看作纵坐标），每个皇后纵坐标都不同。
//lenght表示皇后数
public static bool Check(int[] ColumnIndex, int lenght)
        {
            int i, j;
            num++;
            for (i = 0; i < lenght; i++)//这里的i和j表示两个皇后之间比较，为棋盘的横轴或纵轴，这里将它看作横轴
            {
                for (j = i + 1; j < lenght; j++)//j=i+1，表示两个皇后的横坐标不可能相等。
                {
                    if (i - j == ColumnIndex[i] - ColumnIndex[j] || j - i == ColumnIndex[i] - ColumnIndex[j])
                    {
                        return false;
                    }
                }
            }
            return true;
        }

其次说明全排列：

利用递归的方法实现全排列的基本思路：

1、八个皇后的排列的问题比较棘手，那么七个会比八个简单点，六个，五个······两个更简单，只需要交换两个皇后的前后位置，就完成了两个皇后的全排列，两个皇后的全排列完成后，再加入第三个，第四个······第八个。

ColumnIndex表示八个皇后的编号（0到7）组成的数组;lenght表示数组长度，index表示开始排序索引（从索引为0开始）
public static void permutation(int[] ColumnIndex, int lenght, int index)
        {
            if (index == lenght)//如果到最后一个皇后则检查是否合法，如果合法就输出。
            {
                if (Check(ColumnIndex, lenght))//判断是否合法
                {
                    ++g_number;//合法数量加一
                    Print(ColumnIndex, lenght);//输出结果
                }
            }
            else
            {
                //全排列主要代码
                for (int i = index; i < lenght; ++i)
                {
                    swap(ref ColumnIndex[index], ref ColumnIndex[i]);//交换值
                    permutation(ColumnIndex, lenght, index + 1);//进入递归
                    swap(ref ColumnIndex[index], ref ColumnIndex[i]);//交换回来
                }
            }
        }

完整代码：

namespace EightQueenTest
{
    class Program
    {
        static int g_number = 0;//记录满足八皇后问题的数量编号
        static int num = 0;//记录全排列的结果数量

        static void Main(string[] args)
        {
            EightQueen();
            Console.WriteLine("共有全排列结果" + num + "种");
            Console.WriteLine("满足八皇后条件" + g_number + "种");
            Console.ReadKey();
        }

        public static void EightQueen()
        {
            const int queens = 8;
            int[] ColumnIndex = new int[queens];
            for (int i = 0; i < queens; i++)//初始化皇后数组
            {
                ColumnIndex[i] = i;
            }
            permutation(ColumnIndex, queens, 0);//调用函数
        }
        /// <summary> 
        ///全排列
        /// </summary>
        /// <param name="ColumnIndex">皇后数组</param>
        /// <param name="lenght">数组长度</param>
        /// <param name="index">开始索引</param>
        public static void permutation(int[] ColumnIndex, int lenght, int index)
        {
            if (index == lenght)
            {
                if (Check(ColumnIndex, lenght))
                {
                    ++g_number;
                    Print(ColumnIndex, lenght);
                }
            }
            else
            {
                //全排列主要代码
                for (int i = index; i < lenght; ++i)
                {
                    swap(ref ColumnIndex[index], ref ColumnIndex[i]);
                    permutation(ColumnIndex, lenght, index + 1);
                    swap(ref ColumnIndex[index], ref ColumnIndex[i]);
                }
            }
        }
        /// <summary>
        /// 检查是否满足八皇后条件
        /// </summary>
        /// <param name="ColumnIndex">排列数</param>
        /// <param name="lenght">皇后数</param>
        /// <returns></returns>
        public static bool Check(int[] ColumnIndex, int lenght)
        {
            int i, j;
            num++;
            for (i = 0; i < lenght; i++)
            {
                for (j = i + 1; j < lenght; j++)
                {
                    if (i - j == ColumnIndex[i] - ColumnIndex[j] || j - i == ColumnIndex[i] - ColumnIndex[j])
                    {
                        return false;
                    }
                }
            }
            return true;
        }
        /// <summary>
        ///输出八皇后的排列数
        /// </summary>
        /// <param name="CollumnIndex">皇后数组</param>
        /// <param name="lenght">数组长度</param>
        public static void Print(int[] CollumnIndex, int lenght)
        {
            Console.Write(g_number + ": ");
            for (int i = 0; i < lenght; i++)
            {
                Console.Write(CollumnIndex[i] + " ");
            }
            Console.Write("\n");
        }
        /// <summary>
        ///交换两个参数的值
        /// </summary>
        /// <param name="index">交换的值1</param>
        /// <param name="i">交换的值2</param>
        public static void swap(ref int index, ref int i)
        {
            int temp = index;
            index = i;
            i = temp;
        }
    }
}