算法--皇后问题（回溯法）

皇后问题一般采用深度遍历dfs
采用的是利用递归进行回溯法
题目：
在NN的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。
你的任务是，对于给定的N，求出有多少种合法的放置方法。*

思考：
获取一次合法放置的方法–深度遍历
获取所有合法放置的方法–递归+深度遍历

为了便于存储：
二维存储 通过以为存储代替二维储存（利用数组的下标代替行，数组储存的值代表列，这样可以保证每一行只能存放一个皇后）
不能同一列：
由于并不知道后续的皇后能不能达到不能同一行、同一列、对角线上的标准，所以这里是只做记录不对值进行改变
设立一个数组记录相应的列是否被占用
不能在对角线上（正对角线、反对角线）：
abs(map[step]-map[j])==abs(step-j):行-行=列=列等腰直角三角形

例子–4皇后

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int map[20];
int book[20];
int ans[20];
int n;
int count;

void dfs(int step)
{     int i,flag,j;
      if(step==n+1)
      {    count++;
      		cout<<count<<"lun";
      		printf("\n");
          return ;
	  }
	  for(i=1;i<=n;i++)//找未被放的列;
	  {  if(book[i]==0)
	      {   map[step]=i;
	          flag=1;
	           for(j=1;j<=step-1;j++)//判断是否有放在45度角的;
	            {  if((map[step]-map[j])==(step-j)||(map[step]-map[j])==(j-step))
	                    {
						  flag=0;
	                      break;}//如果存在45度的不符合题意继续找;
				}
				if(flag)
				{   book[i]=1;
					cout<<"存放在"<<step<<"行"<<i <<"列";
					printf("\n");
				    dfs(step+1);
				    book[i]=0;
				}
		  }
	  }
}
int main()
{    int i;
               
			 n=4;
                 count=0;
		         memset(book,0,sizeof(book));
	            memset(map,0,sizeof(map));  
                 dfs(1);
//                 ans[i]=count;
//			//打表输出所有结果更省时
//			while(scanf("%d",&n)!=EOF)
//			{   if(n==0)
//			      break;
//			      printf("%d\n",ans[n]);
//			}
               
       return 0;    
	
}

！！！注意：这里的递归是在循环里面的，所以完成了dfs(4)之后会继续执行book[i]=0，不断地进行搜索

2n 皇后问题
跟n皇后问题相似
BASIC-27. 2n皇后问题
问题描述
给定⼀一个n*n的棋盘，棋盘中有⼀一些位置不不能放皇后。现在要向棋盘中放⼊入n个⿊黑皇后和n个⽩白皇后，
使任意的两个⿊黑皇后都不不在同⼀一⾏行行、同⼀一列列或同⼀一条对⻆角线上，任意的两个⽩白皇后都不不在同⼀一⾏行行、同
⼀一列列或同⼀一条对⻆角线上。问总共有多少种放法？n⼩小于等于8。
输⼊入格式
输⼊入的第⼀一⾏行行为⼀一个整数n，表示棋盘的⼤大⼩小。
接下来n⾏行行，每⾏行行n个0或1的整数，如果⼀一个整数为1，表示对应的位置可以放皇后，如果⼀一个整数为
0，表示对应的位置不不可以放皇后。
输出格式
输出⼀一个整数，表示总共有多少种放法。
样例例输⼊
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例例输出
2
样例例输⼊
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例例输出
0

思考：
首先先进行白皇后的填充（白皇后确定之后）再进行黑皇后的填充
这里同样采用深度遍历+递归
储存规模是两个数组a、b（白皇后、黑皇后存放列的）
并不需要储存列是否被占用，通过数组a即可得知

#include<bits/stdc++.h>
using namespace std;
int n,sum;
int s[10][10];
int a[11],b[11];
void dfs2(int step)//这里的step是行的意思 
{
	int flag;
	if(step==n+1)//如果行满了 
	{
		sum++;
		return ;
	}
	for(int i=1;i<=n;i++)
	{
		if(s[step][i]==0||a[step]==i)//判断是否重叠
		continue;
		flag=1;
		b[step]=i;
		for(int j=1;j<=step-1;j++)
		{
			if(b[step]==b[j]||abs(b[step]-b[j])==step-j)
			{
				flag=0;
				break;
			}
		}
		if(flag)//如果不满足要继续找
		{
			dfs2(step+1);
		}
	}
	return ;
}
void dfs1(int step)
{
	int flag;
	if(step==n+1)
	{
		dfs2(1);
		return ;
	}
	for(int i=1;i<=n;i++)
	{
		flag=1;
		if(s[step][i]==0)
		continue;
		a[step]=i;
		cout<<step<<"行："<<a[step]<<endl;
		//这里的值不需要复位的因为如果当前不满足题意下一次继续查找时会覆盖的。
		for(int j=1;j<=step-1;j++)
		{
			cout<<j<<"列："<<a[j]<<" ";
			if(a[step]==a[j]||abs(a[step]-a[j])==step-j)
			{
				flag=0;
				break;
			}
		}
		if(flag)
			{
				dfs1(step+1);
			}
	}
	return ;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	  for(int j=1;j<=n;j++)
	  scanf("%d",&s[i][j]);
	  sum=0;
	  memset(a,0,11);
	  dfs1(1);
	  printf("\n%d\n",sum);
	  
	  return 0;
}