八皇后问题的递归算法,为什么能输出好几个结果?

code_xbug 2015-01-30 06:46:21
#include<stdio.h>
#include <math.h>
#define SUCCESS 1
#define FAIL 0
#define STATE bool
const int Queen = 5;

int column[Queen];
int number=0;


//输出函数
void Output()
{
++number;
printf("解法编号:%d\n",number);
for (int i=0;i<Queen;++i)
{
for (int j=0;j<Queen;++j)
{
if (column[i]-1==j)
{
printf(" Q");
}
else
printf(" .");
}
printf("\n");

}
printf("\n\n");

}

STATE IsValid(int num)
{
for(int i=0;i<num;++i)
{
//检查是否同列
if (column[i]==column[num])
{
return FAIL;
}
//检查是否同在一条斜线上
if (abs(column[i]-column[num])==(num-i))
{
return FAIL;
}

}
return SUCCESS;
}

//疑问:到底是怎么输出好几个结果的?
//我感觉输出一种结果就会结束这个函数啊
void EightQueen(int num)
{
//如果找到了一种解法,则输出
if (num==Queen)
{
Output();
}
else
{
for (int col=1;col<=Queen;++col)
{
column[num] = col;
if (IsValid(num))
{
EightQueen(num+1);
}
}
}


}


void main()
{

EightQueen(0);

}


研究经典算法的时候对这个递归有点不大能理解,不知道为什么可以输出所有可能结果,我觉得输出一个结果之后就结束了啊。
请各位大神帮忙点化一下QAQ
...全文
284 9 打赏 收藏 转发到动态 举报
写回复
用AI写文章
9 条回复
切换为时间正序
请发表友善的回复…
发表回复
ssdfhrt 2015-01-31
  • 打赏
  • 举报
回复
for (int col=1;col<=Queen;++col) { column[num] = col; if (IsValid(num)) { EightQueen(num+1); } } for循环中一行一行遍历了所有可能的情况,第num行不冲突时,开始遍历下一行, 直到num=queen,输出,之后回到上一行继续遍历
  • 打赏
  • 举报
回复
因为 col 和 num 没实质性的算法关系,所以会有很多层递归,每层递归直到num=5结束
code_xbug 2015-01-31
  • 打赏
  • 举报
回复
引用 5 楼 zhao4zhong1 的回复:
“给定一个小点的输入,完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门! 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出
谢谢!学习到了调试的技巧!
code_xbug 2015-01-31
  • 打赏
  • 举报
回复
引用 4 楼 baidu_23849565 的回复:
for (int col=1;col<=Queen;++col) { column[num] = col; if (IsValid(num)) { EightQueen(num+1); } } for循环中一行一行遍历了所有可能的情况,第num行不冲突时,开始遍历下一行, 直到num=queen,输出,之后回到上一行继续遍历
呃…这个解释我…努力去理解
code_xbug 2015-01-31
  • 打赏
  • 举报
回复
引用 3 楼 q3733353520 的回复:
因为 col 和 num 没实质性的算法关系,所以会有很多层递归,每层递归直到num=5结束
哇,谢谢你的点拨!感觉懂了
就想叫yoko 2015-01-31
  • 打赏
  • 举报
回复

/**                                                                             
 * The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.
 *                                                                              
 * Given an integer n, return all distinct solutions to the n-queens puzzle.    
 *                                                                              
 * Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.
 *                                                                              
 * For example,                                                                 
 *     There exist two distinct solutions to the 4-queens puzzle:               
 *                                                                              
 *     [                                                                        
 *      [".Q..",  // Solution 1                                                 
 *       "...Q",                                                                
 *       "Q...",                                                                
 *       "..Q."],                                                               
 *                                                                              
 *      ["..Q.",  // Solution 2                                                 
 *       "Q...",                                                                
 *       "...Q",                                                                
 *       ".Q.."]                                                                
 *     ]                                                                        
 */                                                                             
                                                                                
#include <stdio.h>                                                              
#include <stdlib.h>                                                             
#include <string>                                                               
#include <vector>                                                               
using namespace std;                                                            
                                                                                
void print_solves(vector<vector<string> > &vec) {                               
    printf("[\n");                                                              
    for (int i = 0; i < vec.size(); ++i) {                                      
        printf(" [\n");                                                         
        for (int j = 0; j < vec[i].size(); ++j) {                               
            printf("%s\n", vec[i][j].c_str());                                  
        }                                                                       
        printf(" ]\n");                                                         
    }                                                                           
    printf("]\n");                                                              
}                                                                               
                                                                                
                                                                                
class Solution {                                                                
    public:                                                                     
        int diff(int x, int y) {                                                
            return x > y ? x - y : y - x;                                       
        }                                                                       
                                                                                
        int succ(int index) {                                                   
            for (int i = 1; i < index; ++i) {                                   
                if (array_[index] == array_[i] || (diff(index, i) == diff(array_[index], array_[i]))) {
                    return 0;                                                   
                }                                                               
            }                                                                   
            return 1;                                                           
        }                                                                       
                                                                                
        void solve_n_queens(int index) {                                        
            if (index > n_) {                                                   
                vector<string> vec;                                             
                for (int i = 0; i < n_; ++i) {                                  
                    string str(n_, '.');                                        
                    str[array_[i + 1] - 1] = 'Q';                               
                    vec.push_back(str);                                         
                }                                                               
                result_.push_back(vec);                                         
                return;                                                         
            }                                                                   
                                                                                
            for (int i = 1; i <= n_; ++i) {                                     
                array_[index] = i;                                              
                if (succ(index)) {                                              
                    solve_n_queens(index + 1);                                  
                }                                                               
            }                                                                   
        }                                                                       
                                                                                
        vector<vector<string> > solveNQueens(int n) {                           
            n_ = n;                                                             
            array_.resize(n + 1, 0);                                            
            solve_n_queens(1);                                                  
            return result_;                                                     
        }                                                                       
                                                                                
    private:                                                                    
        int n_;                                                                 
        vector<int> array_;                                                     
        vector<vector<string> > result_;                                        
};                                                                              
                                                                                
                                                                                
int main(int argc, char **argv) {                                               
    int i = 8;                                                                  
    if (argc == 2) {                                                            
        i = atoi(argv[1]);                                                      
    }                                                                           
    Solution s;                                                                 
    //for (int i = 0; i < 9; ++i) {                                             
    vector<vector<string> > ret = s.solveNQueens(i);                            
    printf("%d size:%d.\n", i, ret.size());                                     
    //}                                                                         
    print_solves(ret);                                                          
    return 0;                                                                   
} 
赵4老师 2015-01-31
  • 打赏
  • 举报
回复
“给定一个小点的输入,完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门! 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出
code_xbug 2015-01-30
  • 打赏
  • 举报
回复
引用 1 楼 baidu_23849565 的回复:
for (int col=1;col<=Queen;++col) { column[num] = col; if (IsValid(num)) { EightQueen(num+1); } } 注意for循环
还是没懂OTL……可否详细讲一下?
ssdfhrt 2015-01-30
  • 打赏
  • 举报
回复
for (int col=1;col<=Queen;++col) { column[num] = col; if (IsValid(num)) { EightQueen(num+1); } } 注意for循环

69,373

社区成员

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧