N皇后

题目：八皇后问题：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

思路：

递归实现N皇后问题：

1.最外层循环SetQueenPosition控制最新的Queen的位置

2.第二层循环IsConflictWithLast 判断最新的Queen是否与之前排位置的Queen冲突，全部都不冲突才将位置存进数组

3.如果最新的Queen将所有位置都试了一遍之后，仍然找不到符合规则的位置，则修改上一个Queen的位置

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NQueen
{
    class Program
    {
        int sumResult = 0;
        int qNum =8;
        int[] qList = new int[8];//保存queen所处的位置信息，index是行，value是列
        static void Main(string[] args)
        {
            Program pg = new Program();
            pg.SetQueenPosition(0);
            Console.WriteLine(pg.sumResult);
            Console.ReadKey();
        }
        /// <summary>
        /// 放置Queen
        /// </summary>
        /// <param name="readyQNum">已经排好位置的Queen的个数</param>
        public void SetQueenPosition(int readyQNum)
        {
            for (int qpnn = 1; qpnn < qNum + 1; qpnn++)
            {
                if (readyQNum == qNum)
                {
                    sumResult++;
                    Print(qNum, qList);
                    break;   //需要跳出循环才能避免与上次结果重复                
                }
                else
                {
                    if (!IsConflictWithReadyQueen(qpnn, readyQNum))//如果当前位置和已经安放好的Queen没有冲突
                    {
                        qList[readyQNum] = qpnn;
                        SetQueenPosition(readyQNum + 1); //如果循环一遍之后发现readyQNum + 1位置的值不能找到的话，会将readyQNum位置的值重新计算
                    }
                }
            }
        }

        /// <summary>
        /// 判断当前位置的Queen是否与所有排好位置的Queen有冲突
        /// </summary>
        /// <param name="queen">当前Queen的列号</param>
        /// <param name="readyQNum">已经排好位置的Queen的个数</param>
        /// <returns>有冲突返回true，无返回false</returns>
        public bool IsConflictWithReadyQueen(int queen, int readyQNum)
        {
            if (readyQNum == 0)
            {
                return false;//如果当前queen是第一个，那么直接返回false--没有冲突
            }
            else
            {
                //循环第i个已经排好位置的queen
                for (int i = 0; i < readyQNum; i++)
                {
                    if (IsConflictWithLast(readyQNum - i, qList[i], queen))
                    {
                        return true; //有冲突，返回true
                    }
                }
                return false; //当前位置的queen和前面的所有元素都比较过了没有冲突，可以返回false--没有冲突
            }

        }

        /// <summary>
        /// 判断当前位置的Queen是否与指定的ReadyQueen有冲突
        /// </summary>
        /// <param name="rowNum">行数差</param>
        /// <param name="last">指定的ReadyQueen的列号</param>
        /// <param name="queen">当前Queen的列号</param>
        /// <returns>有冲突返回true，无返回false</returns>
        public bool IsConflictWithLast(int rowNum, int last, int queen)
        {

            //当前皇后是否与上个处在同一列，或者两个皇后的列差是否等于行差，是的话即同处对角线上
            if (queen == last || Math.Abs(last - queen) == rowNum)
            {
                return true;
            }
            return false;
        }

        public void Print(int qNum,int[] qList)
        {
            Console.WriteLine("Queen position {0}", sumResult);
            for (int i = 0; i < qNum; i++)//循环第i个queen
            {
                for (int j = 1; j < qList.Length + 1; j++)//循环第i个queen的位置，位置是1-8
                {
                    if (j == qList[i])
                    {
                        Console.Write("■");
                    }
                    else
                    {
                        Console.Write("O");
                    }
                }
                Console.Write("
");
            }
        }
    }
}