算法篇----八皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 

using System;
using System.Collections.Generic;
namespace NET.MST.Thirteenth.Queen
{
    /// <summary>
    /// 皇后问题内核模块
    /// </summary>
    public partial class Queens
    {
        //棋盘列表，每一项代表一个解的棋盘
        private List<int[]> _chessBoard;
        //维度
        private int _dimension;
        /// <summary>
        /// 不允许默认的公共构造方法
        /// </summary>
        private Queens()
        {
        }
        /// <summary>
        /// 构造方法，需要提供维度来构造
        /// </summary>
        /// <param name="n">维度</param>
        public Queens(int n)
        {
            //初始化解
            _chessBoard = new List<int[]>(n);
            //存储维度
            _dimension = n;
            //计算并得到所有解
            Calculate();
        }
        /// <summary>
        /// 只读属性，返回维度
        /// </summary>
        public int Dimension
        {
            get
            {
                return _dimension;
            }
        }
        public int[] GetChessBoard(int index)
        {
            if (_chessBoard.Count <= index||
                index<0)
                return null;
            int[] result = new Int32[_dimension];
            Array.Copy(_chessBoard[index], result, result.LongLength);
            return result;
        }
        /// <summary>
        /// 得到解的数量
        /// </summary>
        public int GetCount()
        {
            return _chessBoard.Count;
        }
    }
    /// <summary>
    /// 回朔算法的实现
    /// </summary>
    public partial class Queens
    {
        /// <summary>
        /// 计算入口
        /// </summary>
        private void Calculate()
        {
            //初始化一个棋盘
            int[] board = new Int32[_dimension];
            //循环摆放N个皇后，直至第一皇后也需要回朔
            for (int j = 0; j < _dimension && j >= 0; )
            {
                //是否需要回朔的标志
                bool found = false;
                //从第一列摆放到第N列
                for (int i = board[j]; i < _dimension; i++)
                {
                    //检查是否有冲突
                    if (NoConflict(j, board, i))
                    {
                        //表示没有冲突，实际摆放当前皇后
                        board[j] = i;
                        //如何当前摆放的是最后一个皇后，则表明已经找到一个解
                        if (j == (_dimension - 1))
                        {
                            //复制当前棋盘并且存储这个解
                            int[] result = new Int32[_dimension];
                            board.CopyTo(result, 0);
                            _chessBoard.Add(result);
                            //一个解得到后，就需要回朔来寻找下一个解
                            found = false;
                        }
                        //不需要回朔
                        else
                            found = true;
                        break;
                    }
                }
                if (!found)
                {
                    //这里回朔，复位当前皇后
                    board[j] = 0;
                    //回朔到上一个皇后
                    j = j - 1;
                    if (j >= 0)
                        board[j]++;
                }
                else
                    j++;
            }
        }
        /// <summary>
        /// 检查当前摆放是否有冲突
        /// </summary>
        /// <param name="index">现在摆放第几个皇后</param>
        /// <param name="board">当前棋盘</param>
        /// <param name="val">当前尝试摆放的列数</param>
        /// <returns></returns>
        private bool NoConflict(int index, int[] board, int val)
        {
            //循环检查当前摆放是否和已经摆放的皇后有冲突
            //由于是逐行摆放的，所以不存在两个皇后在同一行的可能，只检查列和斜线
            for (int i = 0; i < index; i++)
            {
                if (board[i] == val ||  //在同一列上
                    (index - i) == Math.Abs(board[i] - val))//在同一斜线上
                    return false;
            }
            //检查接触，无冲突
            return true;
        }
    }
}