8皇后问题

这个算法还是比较简单. 看代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace N皇后问题
{
    //问题描述: 在1个 N X N的棋盘上放N个皇后，要求不能互相攻击，问如何摆放.
    //因为每个皇后不能在同一行，那么这个解的位置可以使用列的位置就可以表示了，因此使用一个8元素的数组来表示这个题的
    //解法.
    //再往下看，其实可以演变为求一个由指定字符组成的字串的全排列组合, 再验证每一种组合的可能性.
    class Program
    {
        static void Main(string[] args)
        {
            //int[] result = new int[8];
            DateTime start = DateTime.Now;
            string cols = "01234567";//用以产生一个全排列. 稍加修改, 在这里还可以计算 9, 10皇后的结果

            char[] arr_cols = cols.ToCharArray();
            string[] result = get_all_position(null, arr_cols, arr_cols.Length);
            //得到所有的可能的组合.
            //每个皇后的坐标为, X: 数组元素的下标, Y: 当前值.

            //现在需要一个验证方法.
            int result_count = 0;
            StringBuilder sb = new StringBuilder();
            for (int kk = 0; kk < result.Length; kk++)
            {
                if (validate(result[kk]))
                {
                    result_count++;
                    sb.Append(result[kk]);
                    sb.Append(" | ");
                }
            }

            DateTime end = DateTime.Now;

            TimeSpan span = (TimeSpan)(end  - start);
            Console.Write(sb.ToString());
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("总解的个数为: " + result_count.ToString() + " 个");
            Console.WriteLine("耗费时间: " + span.TotalSeconds.ToString());
            Console.ReadLine();
        }
        static string[] get_all_position(string[] all_position, char[] arr_char, int level)
        {
            string[] base_position = null;

            if (level == 0)
                return new string[] { arr_char[0].ToString() };
            else
                base_position = get_all_position(all_position, arr_char, level - 1);

            if (level == arr_char.Length)
                return base_position;

            char new_char = arr_char[level];

            int string_length = 0;
            if (base_position.Length > 0)
                string_length = base_position[0].Length;

            string[] new_position = new string[base_position.Length * (level + 1)];

            for (int i = 0; i < base_position.Length; i++)
            {
                new_position[(string_length + 1) * i] = new_char + base_position[i];
                for (int k = 0; k < string_length; k++)
                {
                    new_position[(string_length + 1) * i + k + 1] = base_position[i][k] + base_position[i].Replace(base_position[i][k], new_char);
                }
            }

            return new_position;
        }

        static bool validate(string position)
        {
            char[] arr = position.ToCharArray();
            int length = arr.Length;
            for (int k = 0; k < length; k++)
            {
                int x1 = k;
                int y1 = int.Parse(arr[k].ToString());
                for (int m = k + 1; m < length; m++)
                {
                    int x2 = m;
                    int y2 = int.Parse(arr[m].ToString());

                    if (y1 == y2 || Math.Abs(x1 - x2) == Math.Abs(y1 - y2))
                        return false;
                }
            }

            return true;
        }
    }
}