精华内容
下载资源
问答
  • 8皇后

    2016-09-22 19:16:16
    8皇后问题 采用回溯算法 思路是按行来规定皇后,第一行放第一个皇后,第二行放第二个,然后通过遍历所有列,来判断下一个皇后能否放在该列。直到所有皇后都放完,或者放哪都不行。  详细一点说,第一个皇后先...


    8皇后问题

    采用回溯算法

    思路是按行来规定皇后,第一行放第一个皇后,第二行放第二个,然后通过遍历所有列,来判断下一个皇后能否放在该列。直到所有皇后都放完,或者放哪都不行。

        详细一点说,第一个皇后先放第一行第一列,然后第二个皇后放在第二行第一列、然后判断是否OK,然后第二列、第三列、依次把所有列都放完,找到一个合适,继续第三个皇后,还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置,算是找到了一个正确解。然后回头继续第一个皇后放第二列,后面继续循环……





    package HuiSu;
    
    
    
    
    public class Queen {
    	//皇后的数量
    	static int max = 8;
    	//arr[i]皇后放在 第i行第arr[i]列
    	static int[] arr = new int[max];
    
    
    	public static void main(String[] args) {
    		check(0);
    	}
    
    
    	private static void check(int n) {
    		// 终止条件:当皇后放在最后一行时,打印,回溯
    		if (n == max) {
    			print();
    			return;
    		}
    		for (int i = 0; i < max; i++) {
    			// 在第n行第i列 放入皇后
    			arr[n] = i;
    			// 检验是否冲突
    			if (judge(n)) {
    				// 若不冲突
    				check(n + 1);
    			}
    		}
    
    
    	}
    
    
    	// 判断皇后放入
    	private static boolean judge(int n) {
    		//0--n判断是否有冲突
    		for (int i = 0; i < n; i++) {
    			// arr[i] == arr[n] 处于同一列
    			// Math.abs(n-i)==Math.abs(arr[i]-arr[n]) 处于同一斜线处
    			if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[i] - arr[n]))
    				return false;
    		}
    		return true;
    	}
    
    
    	private static void print() {
    		for (int i = 0; i < max; i++) {
    			System.out.print(arr[i]+1+" ");
    		}
    		System.out.println();
    	}
    }


    展开全文
  • 8皇后问题 8皇后问题 8皇后问题
  • 8皇后代码,8皇后代码8皇后代码8皇后代码8皇后代码8皇后代码8皇后代码
  • 8皇后问题

    2017-10-31 12:10:32
    八皇后问题是大数学家高斯于1850年提出来的。该问题是在8×8的国际象棋棋盘上放置8个皇后,使得没有一个皇后能“吃掉”任何其他一个皇后,即没有任何两个皇后被放置在棋盘的同一行、同一列或...输出8皇后问题所有结果
    

     

    8皇后问题

     

    描述:

    八皇后问题是大数学家高斯于1850年提出来的。该问题是在8×8的国际象棋棋盘上放置8个皇后,使得没有一个皇后能“吃掉”任何其他一个皇后,即没有任何两个皇后被放置在棋盘的同一行、同一列或同一斜线上。

    输出8皇后问题所有结果。

    输入:

    没有输入。

    输出:

    每个结果第一行是No n:的形式,n表示输出的是第几个结果;下面8行,每行8个字符,‘A’表示皇后,‘.’表示空格。不同的结果中,先输出第一个皇后位置靠前的结果;第一个皇后位置相同,先输出第二个皇后位置靠前的结果;依次类推。

    输入样例:

    输出样例:

    输出的前几行:
    No 1:
    A.......
    ....A...
    .......A
    .....A..
    ..A.....
    ......A.
    .A......
    ...A....
    No 2:
    A.......
    .....A..
    .......A
    ..A.....
    ......A.
    ...A....
    .A......
    ....A...

    答案:

    #include<stdio.h>

    #include<math.h>//要用到绝对值函数

     

    inta[8];

    intcounter=1;//计数器

     

    voidsearch(int m); //递归函数

    intcanplace(int row,int col);//判断是否满足八皇后的条件

    voidoutput();

     

    intmain()

    {

       search(0);//初始化为0

    }

     

    voidsearch(int m)

    {

         int i;

            if(m==8)

            {

                output();

            }

        else

        {

            for(i=0;i<8;i++)

               {

                    if(canplace(m,i))

                    {

                         a[m]=i;

                         search(m+1);

                    }

               }     

        }

    }

     

    intcanplace(int row,int col)

    {

         int i,flag=1;

         for(i=0;i<row;i++)

         {

               if(a[i]==col||fabs(row-i)==fabs(col-a[i]))

               {

                    flag=0;

                    break;

               }

         }

         return(flag);

    }

     

    voidoutput ()

    {

         int i,j;

         printf("No ");

         printf("%d",counter);

         printf(":\n");

         counter++;

         for(i=0;i<8;i++)

         {

               for(j=0;j<8;j++)

               {

                    if(j==a[i])printf("A");

                    else printf(".");

               }

               printf("\n");

         }

        

    }

    注意:

    1. 本题用a[m]=j来表示皇后在第m行第j列,所以输出时一行只有一个皇后,故在canplace中无需再判断

    2. 输出时要二重循环才能输出矩阵

    3. a[i]==col  表示同一列的前n-1行中有皇后

    4. fabs(row-i)==fabs(col-a[i]) 表示在同一斜线上或在同一反斜线上

       

       

       

       

    展开全文
  • 简单的8皇后代码,具有记录所有8皇后结果功能,递归实现!
  • 比较经典的8皇后问题 与大家共享比较经典的8皇后问题 与大家共享比较经典的8皇后问题 与大家共享
  • 皇后问题,8皇后、n皇后、2n皇后

    千次阅读 2019-10-29 22:39:24
    8皇后问题 问题描述: 八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。 该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出: 在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都...

    8皇后问题

    问题描述:

    八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。
    该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:
    在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
    高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。
    计算机发明后,有多种计算机语言可以解决此问题。

    分析:

    一、八重循环列举出所有的结果,在其中筛选满足条件的结果,不过显而易见,这样的话效率会很低,这里不再赘述
    二、深度优先遍历搜索,以行为基准,在每一行找满足条件的点,若找到,则进入下一行继续找,若没有找到,则回溯到上一行切入点的后边继续找,直到在尾行找到满足条件的点为止,,则一组序列已经找到,继续回溯到上一行,找其他组的序列,若倒数第二行已经全部找完所有可能的序列,则继续回溯,继续dfs搜索…,直到找到所有组合为止
    基于这种思想,可以用递归+回溯的思想或者迭代+回溯的思想进行解决

    具体的算法细节及分析都在代码注释中表明!

    代码:
    
    //************递归+回溯
    
    #include<iostream>
    using namespace std;
    #include<cmath>
    
    int queen[8] = { 0 };  //用一维数组来维护皇后落子的点,例如,queen[1] = 5表示第2行第6列有一个落子点(从0开始)
    int _count = 0;
    
    // 检测冲突,若冲突返回真
    //    行 --------- 列
    // point_r ----- point_c   要检测的行和列(确定的点)
    //   row ------- queen[row]  前n行已经找出来的点,看point是否与之前找出来的行列冲突
    bool IsAttack(int point_r, int point_c)
    {
    	for (int row = 0; row < point_r; ++row)
    	{
    		//由于是在把前n-1行中确定的每个点 与 第n行中的point点进行比较,所以不需要进行同一行的判断,肯定不相等
    		//只需检测 point点 是否与 前n-1行中的每个点 列号相等   或者  斜率相等,即在同一对角线上
    		if (point_c == queen[row] || (abs(queen[row] - point_c) == point_r - row))
    		{
    			return true;
    		}
    	}
    	return false;
    }
    
    //找点,递归,回溯
    void find(int row)  //row为行号
    {
    	for (int col = 0; col < 8; ++col)  //遍历第row行中的每一列,确定当前的选中点
    	{
    		if (!IsAttack(row, col))  //不起冲突时
    		{
    			if (row == 7)  //已经进行到第7行,且第7行中的点已经确定时,代表一种组合已经确定,计数器++;回溯,返回第6层找其他的组合
    			{
    				_count++;
    				return;
    			}
    			queen[row] = col;  
    			find(row + 1);  //递归,没在尾行,且已经确定当前行的具体点,进入下一行的查找
    		}
    	}
    	//最内层的循环确定,回溯到其他层,继续查找其他组合
    }
    
    int main()
    {
    	find(0);
    	cout << _count << endl;
    
    	return 0;
    }
    
    
    
    //************迭代+回溯
    
    #include<iostream>
    using namespace std;
    #include<cmath>
    
    int queen[8] = { -1 };
    int _count = 0;
    
    
    bool IsAttack(int point_r, int point_c)
    {
    	for (int row = 0; row < point_r; ++row)
    	{
    		if (point_c == queen[row] || abs(point_c - queen[row]) == point_r - row)
    		{
    			return true;
    		}
    	}
    	return false;
    }
    
    void find()
    {
    	int row = 0, col = 0;
    	while (row < 8)  //控制行
    	{
    		while (col < 8)  //控制列
    		{
    			if (!IsAttack(row, col))  //当前的点不起冲突时
    			{
    				queen[row] = col;  
    				if (row == 7)  //检测当前点是否在尾行,即是否找到一组完整的解
    				{
    					_count++;  //计数器计数
    					col++;  //循环自增到不满足条件,跳转到if(col==8)这一代码块中进行回溯处理,用时间换代码冗余量
    //					queen[row] = -1;
    				}
    				else
    				{
    					col = 0;  //去下一行
    					break;
    				}
    			}
    			else
    			{
    				col++;  //当前点不满足,找当前行的下一个点
    			}
    		}
    		//回溯
    		if (col == 8)  //当前待检测的点越界
    		{
    			row--;  //回溯一行
    			if (row < 0)  //若回溯出界,则程序运行结束
    			{
    				return;
    			}
    			else
    			{
    				col = queen[row];  
    				col++;  //在上一行已确定的点之后继续找
    //				queen[row] = -1;
    				continue;
    			}
    		}
    		row++;  
    	}
    }
    
    int main()
    {
    	find();
    	cout << _count << endl;
    
    	return 0;
    }
    
    

    n皇后问题

    其实要是完全理解了8皇后的思路,就会发现这两个问题其实是一样的处理办法,甚至代码都是一样的,只不过将8改为n就好,不过,为了充门面,还是把源码贴出来叭…

    代码
    
    //************递归 + 回溯
    #include<iostream>
    using namespace std;
    #include<cmath>
    
    int n = 0;  //n个皇后
    int queen[10] = { -1 };
    int _count = 0;
    
    bool IsAttack(int point_r, int point_c)
    {
    	for (int row = 0; row < point_r; row++)
    	{
    		if (point_c == queen[row] || abs(point_c - queen[row]) == point_r - row)
    		{
    			return true;
    		}
    	}
    	return false;
    }
    
    void find(int row)
    {
    	for (int col = 0; col < n; col++)
    	{
    		if (!IsAttack(row, col))
    		{
    			if (row == n - 1)
    			{
    				_count++;
    				return;
    			}
    			queen[row] = col;
    			find(row + 1);
    		}
    	}
    }
    
    int main()
    {
    	cin >> n;
    	find(0);
    	cout << _count << endl;
    
    	return 0;
    }
    
    // *********************迭代+回溯
    #include<iostream>
    using namespace std;
    #include<cmath>
    
    int n = 0;  //n个皇后
    int queen[10] = { -1 };
    int _count = 0;
    
    bool IsAttack(int point_r, int point_c)
    {
    	for (int row = 0; row < point_r; row++)
    	{
    		if (point_c == queen[row] || abs(point_c - queen[row]) == point_r - row)
    		{
    			return true;
    		}
    	}
    	return false;
    }
    
    void find()
    {
    	int row = 0, col = 0;
    	while (row < n)
    	{
    		while (col < n)
    		{
    			if (!IsAttack(row, col))
    			{
    				queen[row] = col;
    				if (row == n - 1)
    				{
    					_count++;
    					col++;
    				}
    				else
    				{
    					col = 0;
    					break;
    				}
    			}
    			else
    			{
    				col++;
    			}
    		}
    		if (col == 8)
    		{
    			row--;
    			if (row < 0)
    			{
    				return;
    			}
    			col = queen[row];
    			col++;
    			continue;
    		}
    		row++;
    	}
    }
    
    int main()
    {
    	cin >> n;
    	find();
    	cout << _count << endl;
    
    	return 0;
    }
    
    

    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

    具体思路

    其实吧,2n皇后就是n皇后问题的加强版,不过是需要在n皇后的基础上在加上一层n皇后。

    首先,用一个数组将有限制的地址存储,等待后面的判断
    其次,类似n皇后一样,分别用两个一维数组将黑白皇后的落子序列存储起来,数组下标为对应的行号,通过下标访问的值为列号
    然后,类似n皇后,先深度优先遍历搜索将一个皇后的落子序列平铺出来,在此基础上,对另一个皇后的所有落子情况进行深度优先遍历搜索,当搜索到尾行且此时落子存在时,表示当前的一种解法可以将两个皇后的子全部落入棋盘中,此时计数器自增,然后再进行类似的回溯,找其他解法,直到全部找出来位置

    代码
    
    #include<iostream>
    using namespace std;
    #include<cmath>
    
    int n = 0;  //2n皇后
    int m[10][10];  //地图
    int blackPos[10], whitePos[10];  //黑白皇后的选点集,下标表示行,通过下标访问的值为列
    int _count = 0;  //方法计数器
    
    bool IsAttack(int pos[], int point_r, int point_c)  //当前点是否冲突
    {
    	for (int row = 0; row < point_r; row++)
    	{
    		if (point_c == pos[row] || abs(point_c - pos[row]) == point_r - row)
    		{
    			return true;
    		}
    	}
    	return false;
    }
    
    //黑皇后落子
    void SetBlack(int row)
    {
    	if (row == n)
    	{
    		//黑皇后已落了n个子,计数器+1
    		_count++;
    		return;
    	}
    	//深度优先遍历搜索 黑皇后选定落子序列
    	for (blackPos[row] = 0; blackPos[row] < n; blackPos[row]++)
    	{
    		if (!IsAttack(blackPos, row, blackPos[row]) && m[row][blackPos[row]] == 1 && blackPos[row] != whitePos[row])
    		{
    			SetBlack(row + 1);
    		}
    	}
    }
    
    //白皇后落子
    void SetWhite(int row)
    {
    	if (row == n)
    	{
    		//白皇后已经落了n个子,即白皇后的一种序列已经确定,在此基础上对黑皇后的落子集合进行搜索
    		SetBlack(0);
    		return;
    	}
    	//深度优先遍历搜索,查找白皇后落子的序列
    	for (whitePos[row] = 0; whitePos[row] < n; whitePos[row]++)
    	{
    		if (!IsAttack(whitePos, row, whitePos[row]) && m[row][whitePos[row]] == 1)
    		{
    			SetWhite(row + 1);
    		}
    	}
    }
    
    int main()
    {
    	cin >> n;
    	for (int i = 0; i < n; ++i)
    	{
    		for (int j = 0; j < n; ++j)
    		{
    			cin >> m[i][j];
    		}
    	}
    	SetWhite(0);
    	cout << _count << endl;
    	return 0;
    }
    
    展开全文
  • 8皇后问题一共有92组解, 8皇后必定不能同一行,因此按行来依次放置皇后到不同列。 解决这个问题主要用到递归来依次放置8个皇后,每次放置要check放置是否合理,合理的进入下一个皇后放置,不合理的continue本次...

    皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上(有8 × 8个方格),使它们谁也不能被吃掉!这就是著名的八皇后问题。

    8皇后问题一共有92组解,

    8皇后必定不能同一行,因此按行来依次放置皇后到不同列。

    解决这个问题主要用到递归来依次放置8个皇后,每次放置要check放置是否合理,合理的进入下一个皇后放置,不合理的continue本次循环,直至本行没有位置返回上一级皇后放置。

    对于N皇后也是如此。

    输出八皇后的指定n组序列:

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    int way[92][9], tem[9], k = 1, n = 8, tim = 0;
    //int aaaaaaaa = 0;
    
    //检查棋盘是否合理,1合理0不合理
    int check(){
    	for (int i = 1; i <= k; i++)//检查第i个皇后是否合理
    	{
    		for (int j = i + 1; j <= k; j++)
    		{
    			if ((tem[i] == tem[j]) || (tem[i] - tem[j] == i - j) || (tem[i] - tem[j] == j - i))//在同一列,对角线
    				return 0;
    		}
    	}
    	return 1;
    }
    //fun递归来放置皇后
    int fun(){
    	for (int i = 1; i <= 8; i++)
    	{
    		tem[k] = i;//临时存放皇后k的列
    		if (check()==0){//不通过
    			continue;
    		}
    		if (k == 8){//全部摆放完
    			for (int j = 1; j <= 8; j++)
    				way[tim][j] = tem[j];
    			tim++;//组数
    		//	printf("%d\n", aaaaaaaa);
    		//	aaaaaaaa++;
    			tem[k] = 0;
    			continue;
    		}
    		k++;
    		fun();
    	}
    	tem[k] = 0;
    	k--;
    	return 0;
    }
    
    int main(){
    	int n,ans[92];
    	scanf("%d", &n);
    	for (int i = 0; i < n; i++)
    		scanf("%d", &ans[i]);
    	fun();
    	for (int i = 0; i < n; i++){
    		for (int j = 1; j <= 8; j++)
    			printf("%d", way[ans[i]-1][j]);
    		printf("\n");
    	}
    	return 0;
    }

     

    展开全文
  • 8皇后问题和由他推广得到的N皇后问题。题目来源于国际象棋的玩法,因为皇后所在的位置可以纵向、横向、两个斜向四个方向的“捕捉”,所以8皇后问题就是要求如何布置8个皇后在8*8的棋盘上而使他们互相无法“捕捉”。...
  • js编写8皇后

    2019-07-31 16:10:24
    8皇后,是我最开始学习开发的主要动力。 很早的时候就想编写js版本的8皇后,棋盘棋子,都好做。但是js的暂停不会做。一直搁浅。 这次编写是把暂停相关饶了过去以达到可接受效果。 效果图 代码库...
  • 8皇后回溯法

    2017-11-22 16:44:44
    8皇后是典实际上一个类似枚举的搜索尝试过程,它的的基本思想是在所有的解空间中,先深度搜索求出一种解法不满足约束条件的解时,回退到之前的解,继续对问题求解8皇后也可以推广为一般情形,将棋盘扩展为n*n,此时...
  •  规则同8皇后问题,但是棋盘上每格都有一个数字,要求八皇后所在格子数字之和最大。 输入格式  一个8*8的棋盘。 输出格式  所能得到的最大数字和 样例输入 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ...
  • 回溯法解决2n皇后(8皇后)问题

    千次阅读 2017-02-06 17:15:46
    8皇后问题是算法入门的经典,在8*8的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一 行,同一列,或者同一斜线上。关于8皇后的解法请见:http://www.cnblogs.com/newflydd/p/5091646.html...
  • C语言 8皇后问题

    2017-10-31 21:51:46
    8皇后问题 时限:1000ms 内存限制:10000K 总时限:3000ms 描述: 输出8皇后问题所有结果。 输入: 没有输入。 输出: 每个结果第一行是No n:的形式,n表示输出的是第几个结果;下面8行,每行8...
  • 初级8皇后问题

    2014-08-26 17:29:27
    初级8皇后问题,不是真正的8皇后问题,是该问题的初级条件限制:产生不同行,不同列的组合。 typedef struct Spoint { int x; int y; Spoint() { x = -1; y = -1; } }; static Spoint point[8]; int ...
  • 1007 8皇后问题

    2017-10-31 13:51:31
    8皇后问题 时限:1000ms 内存限制:10000K 总时限:3000ms 描述: 输出8皇后问题所有结果。 输入: 没有输入。 输出: 每个结果第一行是No n:的形式,n表示输出的是第几个结果;下面8行,每行8...
  • 经典问题:8皇后

    2017-03-03 09:40:34
    8皇后是一个经典问题,大意就是8*8的棋盘上放8个皇后棋子,其中这八个棋子不同行不同列不同斜线。看了很多解题的方法,这里先记录一种。 分析见代码: #include using namespace std; int sum; //打印函数 void ...
  • 回溯法求解8皇后问题的优化 这是我第二次写博客了,第一次是五分钟前。马上就写完的时候浏览器突然崩溃了,还没有保存,心痛! 8皇后问题描述 八皇后问题是一个以国际象棋为背景的问题:如何能够在 8×8 的国际...
  • Java 8皇后基础版

    2020-06-13 18:21:10
    Java 8皇后基础版 问题加思路 1.首先每一个皇后都独居一行,所以可以使用一维数组代表二维数组; 2.每个皇后不同行,不同列,不在同一斜线; 3.可以将皇后问题变成(x,y)的数学问题。 图片理解八皇后 思路 暴力...
  • 在一个8×8的国际象棋棋盘上放置8皇后,要求每个皇后两两之间不“冲突”,即没有一个皇后能“吃掉”任何其他一个皇后,简单的说就是没有任何两个皇后占据棋盘上的同一行或同一列或同一对角线,即在每一横列、竖列...
  • 回溯法——8皇后问题

    2020-12-09 21:13:45
    回溯法——8皇后问题 一、实验内容 1.问题描述 要求用回溯法求解8 —— 皇后问题,是放置在8*8棋盘上的8个皇后彼此不收攻击,即:任何两个皇后都不在同一行、同一列和同一斜线上。 请输出8皇后问题所有可行解。 2、...
  • 数据结构之8皇后问题

    2020-08-12 09:58:06
    在看这篇博文之前,大家可以先玩玩8皇后游戏,在此附上游戏连接点此开始游戏之旅! 8皇后游戏规则是任意在8*8的棋盘上摆放8个皇后,并且这8个皇后之间不能相互攻击(即任意两个皇后不能在同一行,同一列,同一条...
  • 8皇后·改(⼋皇后问题) 问题描述 规则同8皇后问题,但是棋盘上每格都有⼀个数字,要求⼋皇后所在格⼦数字之和最⼤。 输⼊格式 ⼀个8*8的棋盘。 输出格式 所能得到的最⼤数字和 样例输⼊ 1 2 3 4 5 6...
  • 要求用回溯法求解 8-皇后问题,使放置在 8*8 棋盘上的 8皇后彼此不受攻击,即:任 何两个皇后都不在同一行、同一列或同一斜线上。请输出 8 皇后问题的所有可行解。 问题分析 在解决八皇后问题时,如果采用穷举法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,370
精华内容 8,148
关键字:

8皇后