实现n皇后算法

实验内容：

（1）编写程序实现n皇后算法。

（2）画出运行时间与皇后n的关系图。

（3）分析实验结果。

实验过程及记录结果：

n皇后代码：

bool Place(int x[], int t)
{
    for (int i = 1; i < t; i++)
    {
        if (x[i] == x[t] || abs(t - i) == abs(x[t] - x[i]))
        {
            return false; //第t皇后与第i皇后的位置冲突
        }
    }
    return true;
}

//递归函数，尝试放置第t个皇后
void NQueensRec(int x[], int t, int N)
{
    if (t > N)
    { //获得一个可行解，输出该解
        for (int i = 1; i <= N; i++)
        {
            printf("%d ", x[i]);
        }
        printf("\n");
    }
    else
    {
        for (int i = 1; i <= N; i++)
        {
            x[t] = i; //第t皇后放置在第i列
            if (Place(x, t))
            { //第t皇后与之前的皇后位置不冲突，因而继续放置下一皇后。
                NQueensRec(x, t + 1, N);
            }
        }
}
}

结果（以八皇后为例）：

源码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //添加时间头文件

//判断第t个皇后当前放置的位置是否与t之前的皇后位置是否冲突
bool Place(int x[], int t)
{
    for (int i = 1; i < t; i++)
    {
        if (x[i] == x[t] || abs(t - i) == abs(x[t] - x[i]))
        {
            return false; //第t皇后与第i皇后的位置冲突
        }
    }
    return true;
}

//递归函数，尝试放置第t个皇后
void NQueensRec(int x[], int t, int N)
{
    if (t > N)
    { //获得一个可行解，输出该解
        for (int i = 1; i <= N; i++)
        {
            printf("%d ", x[i]);
        }
        printf("\n");
    }
    else
    {
        for (int i = 1; i <= N; i++)
        {
            x[t] = i; //第t皇后放置在第i列
            if (Place(x, t))
            { //第t皇后与之前的皇后位置不冲突，因而继续放置下一皇后。
                NQueensRec(x, t + 1, N);
            }
        }
    }
}

int main()
{
    int x[9];
    clock_t start, end; //定义开始和结束时间变量
    start = clock();    //记录开始时间
    NQueensRec(x, 1, 8); //求解8皇后问题
    end = clock();      //记录结束时间
    double time = (double)(end - start) / CLOCKS_PER_SEC; //计算运行时间
    printf("运行时间为：%f秒\n", time);
    return 0;
}

运行时间与皇后n的关系图:

实验结果：

1.增长趋势：随着皇后数量n的增加，运行时间呈指数级增长。这符合N皇后问题的复杂性，因为N皇后问题在解空间上是一个组合爆炸性问题，随着n的增加，解空间的大小呈指数级增长，导致算法的运行时间也呈指数级增长。

2.稳定性：在较小的n值范围内，运行时间可能会有所波动，这可能受到计算机性能、Python解释器等因素的影响。然而，随着n的增加，算法的运行时间呈现出清晰的增长趋势。

3.算法改进：对于较大的n值，算法的运行时间可能会变得非常长。针对N皇后问题，有一些优化方法和改进算法，例如回溯算法的剪枝优化、启发式搜索等，这些方法可以缩短算法的运行时间。