中国矿业大学-算法实验3，4- 8-皇后问题

题目描述

努比亚和苏丹没有子女，所以他要从一些有集成资格的继承者中挑选一个出来继承王位。他希望这个继承者足够聪明，所以他准备了一个西洋棋盘，上面的每个格子中均有一个 1-99 的数字。他又准备了 8 个皇后棋子。

8 皇后的规则就是不能有任何棋子同行或者同列或者同斜线，在满足这个规则的同时，王位继承者还需要让 8 个皇后所在的位置的数字的和是最大的。

输入

输入一个数字 k(k≤20)，代表棋盘的数量。

接下来有 k 个棋盘，每个棋盘有 64 个数字，分成 8 行 8 列输入，具体可见样例，每一个数字均小于 100。

输出

每一个棋盘对应输出最大的数值， 一共输出 k行

样例输入

1
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48
48 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64

样例输出

260

我们先来看一下n皇后问题

n−皇后问题是指将 n 个皇后放在 n×n

的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。

现在给定整数 n

，请你输出所有的满足条件的棋子摆法。

输入格式

共一行，包含整数 n。

输出格式

每个解决方案占 n

行，每行输出一个长度为 n

的字符串，用来表示完整的棋盘状态。

其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。

每个方案输出完成后，输出一个空行。

注意：行末不能有多余空格。

输出方案的顺序任意，只要不重复且没有遗漏即可。

数据范围

1≤n≤9

输入样例：

4

输出样例：

.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

#include <iostream>

using namespace std;
int N = 20;


int n;
char g[N][N];
bool col[N], dg[N], udg[N];

void dfs(int u)
{
    if (u > n)//u代表行
    {
        for (int i = 1; i <= n; i ++ ) puts(g[i]+1);//从第i行第2个数开始输出 
        puts(" ");
        return;
    }

    for (int i = 1; i <= n; i ++ )
        if (!col[i] && !dg[u + i] && !udg[n - u + i])//列上没有放，两个对角线上也没有放
        {
            g[u][i] = 'Q';
            col[i] = dg[u + i] = udg[n - u + i] = true;
            dfs(u + 1);      //递归加回溯
            col[i] = dg[u + i] = udg[n - u + i] = false;
            g[u][i] = '.';
        }
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            g[i][j] = '.';

    dfs(1);

    return 0;
}

 现在让我们来写，8皇后问题

#include<bits/stdc++.h>
using namespace std;
int a[8][8];
int sum;
int max1;
bool col[20],dg[20],udg[20];//dg[],udg[]必须开2n

void dfs(int u)
{
	if(u==8)      //之前错写成了u==7,但是u==7的时候，sum还没有加上
	{
		max1=max(max1,sum);
		return;
	
	}

	for(int i=0;i<8;i++)
	{
		if(!col[i]&&!dg[u+i]&&!udg[i-u+8])
		{
			sum+=a[u][i];
			col[i]=dg[i+u]=udg[i-u+8]=true;
			dfs(u+1);
			col[i]=dg[i+u]=udg[i-u+8]=false;
			sum-=a[u][i];
		}
	}
}





int main()
{
	int k;
	cin>>k;
	
	while(k--)
	{
		for(int i=0;i<20;i++)
		{
			col[i]=dg[i]=udg[i]=false;// 1.
		}
	
		sum=0;//2.
		max1=0;//3      这几个初始化至关重要，每一次更新新的棋盘都要重置
		
		for(int i=0;i<8;i++)
		{
			for(int j=0;j<8;j++)
			{
				cin>>a[i][j];
			}
		}
		dfs(0);
		cout<<max1<<endl;
	}

}

代码解释：

1.关于对角线的判断，又下图可知：主对角线和副对角线，一个和是常数，一个差是常数，又因为我们用udg[]数组映射表示负对角线，udg[u-i]=udg[x-y](横坐标-纵坐标） x-y有可能为负，参照下面的例子，为了防止越界，我们在映射的时候统一加上一个n，映射的时候相当于往右平移了n .