【蓝桥杯-递归回溯】八皇后问题+N皇后问题

2023年4月14日 292次阅读 来源: 八皇后问题

大致思路：

其实就是三个功能函数：place attack output_solution

place函数中的任务就是把所有的（设为有maxqueen个）皇后的列位置安顿好。其传入的参数仅一个，为皇后的序数q，然后经过i从1~maxqueen的遍历找到该序数q的皇后应在的列数号，使queen[q]=i，条件就是attack(q,i)==false。(那么该皇后的行数号呢？这个要理解，皇后的行数号即其序数号，即q。) 设好列数号之后判断一下是否q==maxqueen-1也就是最后一个皇后放好了，若是，则调用output_solution输出该最终棋盘布局。

attack函数就是判断皇后冲不冲突的。其实就是判断在他（q）之前放好的皇后的列数和q的列数（queen[q]）相不相等，然后看看是不是在同一对角线上。

output_solution就是输出最终的棋盘布局。

  1. /* 
  2.  * 
  3.  * 【问题描述】在一个8×8的国际象棋棋盘上放置8个皇后， 
  4.  * 要求每个皇后两两之间不“冲突”，即没有一个皇后能“吃 
  5.  * 掉”任何其他一个皇后，简单的说就是没有任何两个皇后 
  6.  * 占据棋盘上的同一行或同一列或同一对角线，即在每一横 
  7.  * 列、竖列、斜列都只有一个皇后。 
  8.  * 
  9.  * 递归法求出8个皇后问题的解 
  10.  * 本程序使用一维数组表示皇后的位置，queen[i]的值表示第i行皇后所在的列 
  11.  * 
  12.  * 本程序通过修改宏定义MAXQUEEN的值，可以解决N皇后问题。 
  13.  * 
  14.  */  
  15.   
  16. #include <stdio.h>  
  17. #include <conio.h>  
  18.   
  19. #define TRUE 1  
  20. #define FALSE 0  
  21. #define MAXQUEEN 8  
  22. #define ABS(x) ((x>0)?(x):-(x))  /*求x的绝对值*/  
  23.   
  24. /*存放8个皇后的列位置，数组下标为皇后的列位置*/  
  25. int queen[MAXQUEEN];  
  26. int total_solution = 0;  /*计算共有几组解*/  
  27.   
  28. /*函数原型声明*/  
  29. void place(int);  
  30. int attack(int,int);  
  31. void output_solution();  
  32.   
  33. int main(void)  
  34. {  
  35.     place(0); /*从第0个皇后开始摆放至棋盘*/  
  36.   
  37.     return 0;  
  38. }  
  39.   
  40. /* 递归放置皇后子程序 */  
  41. void place(int q)  //关键！
  42. {  
  43.     int i=0;  
  44.     while(i<MAXQUEEN)  
  45.     {  
  46.         if(!attack(q, i)) /* 皇后未受攻击 */  
  47.         {  
  48.             queen[q]=i; /* 储存皇后所在的列位置 */  
  49.             /* 判断是否找到一组解 */  
  50.             if(q==MAXQUEEN-1)  
  51.                 output_solution(); /* 输出此组解 */  
  52.             else  
  53.                 place(q+1); /* 否则继续摆下一个皇后 */  
  54.         }  
  55.         i++;  
  56.     }  
  57. }  
  58.   
  59. /* 测试在（row,col）上的皇后是否遭受攻击若遭受攻击则返回值为1，否则返回0 */  
  60. int attack(int row, int col)  
  61. {  
  62.     int i, atk=FALSE;  
  63.     int offset_row, offset_col;  
  64.     i=0;  
  65.     while(!atk && i<row)  
  66.     {  
  67.         offset_row=ABS(i-row);  
  68.         offset_col=ABS(queen[i]-col);  
  69.         /* 判断两皇后是否在同一列，是否在同一对角线 */  
  70.         /* 若两皇后在同列或同对角线，则产生攻击，atk==TRUE */  
  71.         atk = (queen[i] == col) || (offset_row == offset_col);  
  72.         i++;  
  73.     }  
  74.     return atk;  
  75. }  
  76.   
  77. /* 输出8个皇后的解 */  
  78. void output_solution()  
  79. {  
  80.     int x,y;  
  81.     total_solution += 1;  
  82.     printf(“Solution#%3d\n\t”,total_solution);  
  83.     for(x=0;x<MAXQUEEN;x++)  
  84.     {  
  85.         for(y=0;y<MAXQUEEN;y++)  
  86.         if(y==queen[x])  
  87.             printf(“Q”); /* 用字母Q表示皇后 */  
  88.         else  
  89.             printf(“-“); /* 用-表示空白 */  
  90.         printf(“\n\t”);  
  91.     }  
  92.     printf(“\n”);  
  93.   
  94.     getchar();  
  95. }  

自己现写的代码如下：


#include<iostream>
#include<bits/stdc++.h>
using namespace std;


int q[9];
int maxx=0;
int a[9][9];


bool attack(int p,int qq)
{
    if(p==1)         return false;
    else
    {
        for(int i=1;i<p;i++)
        {
            if(q[i]==qq)
                return true;
            if(abs(q[i]-qq)==abs(i-p))
                return true;
        }
        return false;
    }
}


void place(int p)
{
    if(p==9)
    {
        int sum=0;
       for(int i=1;i<=8;i++)
       {
           sum+=a[i][q[i]];
       }
        if(maxx<sum)
            maxx=sum;
        return;
    }
    for(int i=1;i<=8;i++) //对第p行的列上递归
    {
        if(attack(p,i)==false)
        {
            q[p]=i;
            place(p+1);
        }
    }
}


int main()
{
    for(int i=1;i<=8;i++)
        for(int j=1;j<=8;j++)
            cin>>a[i][j];
    memset(q,0,sizeof(q));
    place(1);
    cout<<maxx;
    return 0;
}

有必要理解的是，这输出的是多个解。因为place函数里的那个递归啊，之后又i++，也就是序数为q的同一个皇后就算在这一列可以放上，那就将就着去进入递归，弄出一种解决方案，但是！之后仍由着while语句遍历去往下一行尝试。

这就是递归的魅力。你在leetcode上求subset的递归也是这个理儿啊亲——求多种可能！今天明白了原来这叫回溯法

而对于N皇后问题，其实就是把maxQUEEN换成给定的n即可。

以下是原作者海岛Blog发现因为题目要输入多个n求对应的解决方案的个数，每次都去重新算导致Time Limit Exceeded，于是打表 一次性算出1~自己取的num，到时候输入n（题中输入的n<num）直接取ans[n]即可。

N皇后问题

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 27039    Accepted Submission(s): 12035

Problem Description 在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。

你的任务是，对于给定的N，求出有多少种合法的放置方法。

 

Input 共有若干行，每行一个正整数N≤10，表示棋盘和皇后的数量；如果N=0，表示结束。  

Output 共有若干行，每行一个正整数，表示对应输入行的皇后的不同放置数量。  

Sample Input

 1850     
 Sample Output
 19210     
 Author   cgf    
 Source
 2008 HZNU Programming Contest

问题链接：HDU2553 N皇后问题。
问题简述：（略）。
问题分析：这是一个经典的回溯法程序，是用递归来实现的，其实也可以用非递归来实现。回溯法并不是必须用递归来实现的。
 
程序说明：程序的细节还是需要注意的，例如打表时，需要多声明一个元素，因为数组下标是从0开始。
原先做过解N皇后问题的程序，就拿来简单改写了一下。有关程序，参见：八皇后（N皇后）问题算法程序。
一提交，“Time Limit Exceeded”，只好先打表。原来的代码注释留在那里了。
AC的C语言程序如下：
[cpp] 
 view plain
  copy
 
  1. /* HDU2553 N皇后问题 */  
  2.   
  3. #include <stdio.h>  
  4.   
  5. #define TRUE 1  
  6. #define FALSE 0  
  7. #define MAXQUEEN 10  
  8. #define ABS(x) ((x>0)?(x):-(x))  /*求x的绝对值*/  
  9.   
  10. /*存放8个皇后的列位置，数组下标为皇后的列位置*/  
  11. int queen[MAXQUEEN];  
  12. int total_solution;  /*计算共有几组解*/  
  13.   
  14. /* 测试在（row,col）上的皇后是否遭受攻击若遭受攻击则返回值为1，否则返回0 */  
  15. int attack(int row, int col)  
  16. {  
  17.     int i, atk=FALSE;  
  18.     int offset_row, offset_col;  
  19.     i=0;  
  20.     while(!atk && i<row)  
  21.     {  
  22.         offset_row=ABS(i-row);  
  23.         offset_col=ABS(queen[i]-col);  
  24.         /* 判断两皇后是否在同一列，是否在同一对角线 */  
  25.         /* 若两皇后在同列或同对角线，则产生攻击，atk==TRUE */  
  26.         atk = (queen[i] == col) || (offset_row == offset_col);  
  27.         i++;  
  28.     }  
  29.     return atk;  
  30. }  
  31.   
  32. /* 递归放置皇后子程序 */  
  33. void place(int q, int n)    
  34. {  
  35.     int i=0;  
  36.     while(i < n)  
  37.     {  
  38.         if(!attack(q, i))           /* 皇后未受攻击 */  
  39.         {  
  40.             queen[q]=i;             /* 储存皇后所在的列位置 */  
  41.             /* 判断是否找到一组解 */  
  42.             if(q == n-1)  
  43.                 total_solution++;   /* 得到一个解 */  
  44.             else  
  45.                 place(q+1, n);      /* 否则继续摆下一个皇后 */  
  46.         }  
  47.         i++;  
  48.     }  
  49. }  
  50.   
  51. int main(void)  
  52. {  
  53.     int n;  
  54.     int ans[MAXQUEEN+1], i;  
  55.   
  56.     // 因为“Time Limit Exceeded”，只好先打表  
  57.     for(i=1; i<=MAXQUEEN; i++) {  
  58.         // 皇后遍历  
  59.         total_solution = 0;  
  60.         place(0, i);                /*从第0个皇后开始摆放至棋盘*/  
  61.   
  62.         ans[i] = total_solution;  
  63.     }  
  64.   
  65.   
  66.     while(scanf(“%d”, &n) != EOF) {  
  67.         // 判断结束条件  
  68.         if(n == 0)  
  69.             break;  
  70.         printf(“%d\n”, ans[n]);  
  71.     }  
  72.   
  73.     return 0;  
  74. }  
     原文作者：八皇后问题
     原文地址: https://blog.csdn.net/m0_38033475/article/details/79180838
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。 
  点赞