Day 8~Fibonacci,全排列,N皇后问题

分治法将原问题划分为若干个规模较小而结构与原问题相同或相似的问题，然后分别解决这些子问题，最后合并子问题的解，

即可得到原问题的解。

递归最重要的就是递归边界和递归式

求解斐波那契数列前n项

全排列(Full Permutation)。一般把1~n这n个整数按照某个顺序摆放的结果称为这n个整数的排列，而全排列指这n个整数

所能形成的所有排列。例如对1，2，3这三个整数来说（1，2，3）、（1，3，2）、（2，1，3）、（2，3，1）、（3，1，2）

（3，2，1）这就是1~3的全排列。现需要按照字典序从小到大的顺序输出1～n的全排列。

从递归的角度考虑，把问题描述成“输出1～n这n个整数的全排列”，那么它就可以被分为若干个子问题：输出1开头的全排列

输出2开头的全排列....输出n开头的全排列。于是不妨设定一个数组P，用来存放当前的数列，再设定一个散列数组hashTable

其中hashTable[x]当整数x已经在数组P中时为true

现准备按顺序往P的第1位到第n位中填入数字。不妨假设当前已经填好了P[1]~P[index-1],正准备填P[index]。显然需要枚举1～n,

如果当前枚举的数字x还没有在P[1]~P[index-1]中（即hashTable == false）那么就把它填入P[index]，同时将hashTbale[x]置为true，

然后去处理P的index+1位（即进行递归）。递归边界：当index达到n+1时，说明P的1～n位都已经填好，此时可以把数组P输出表示生成了一个排列

，然后直接return即可

#include<stdio.h>
/*
    分治法将原问题划分为若干个规模较小而结构与原问题相同或相似的问题，然后分别解决这些子问题，最后合并子问题的解，
    即可得到原问题的解。
    递归最重要的就是递归边界和递归式
    求解斐波那契数列前n项

    全排列(Full Permutation)。一般把1~n这n个整数按照某个顺序摆放的结果称为这n个整数的排列，而全排列指这n个整数
    所能形成的所有排列。例如对1，2，3这三个整数来说（1，2，3）、（1，3，2）、（2，1，3）、（2，3，1）、（3，1，2）
    （3，2，1）这就是1~3的全排列。现需要按照字典序从小到大的顺序输出1～n的全排列。
    
    从递归的角度考虑，把问题描述成“输出1～n这n个整数的全排列”，那么它就可以被分为若干个子问题：输出1开头的全排列
    输出2开头的全排列....输出n开头的全排列。于是不妨设定一个数组P，用来存放当前的数列，再设定一个散列数组hashTable
    其中hashTable[x]当整数x已经在数组P中时为true
    现准备按顺序往P的第1位到第n位中填入数字。不妨假设当前已经填好了P[1]~P[index-1],正准备填P[index]。显然需要枚举1～n,
    如果当前枚举的数字x还没有在P[1]~P[index-1]中（即hashTable == false）那么就把它填入P[index]，同时将hashTbale[x]置为true，
    然后去处理P的index+1位（即进行递归）。递归边界：当index达到n+1时，说明P的1～n位都已经填好，此时可以把数组P输出表示生成了一个排列
    ，然后直接return即可
*/
int Fibonacci(int n){
    //F(n) = F(n-1) + F(n-2)  n>=2
    if(n ==0 || n == 1) return 1;
    else return Fibonacci(n-1) + Fibonacci(n-2); 
}
const int maxn = 11;
//P为当前数列，hashTable记录整数x是否已经在P中
int n,P[maxn],hashTable[maxn] = {false};
//当前处理排列的第index位
void generateP(int index){
    if(index  == n+1){      //递归边界，已经处理完排列的1～n位
        for(int i = 1;i<=n;i++){
            printf("%d",P[i]);  //输出当前排列
        }
        printf("\n");
        return;
    }

    for(int x = 1;x<=n;x++){    //枚举1～n，试图将x填入P[index]
        if(hashTable[x] == false){      //如果x不在P[0]~P[index-1]中
            P[index] = x;       //令P的第index位为x，即把x加入当前排列
            hashTable[x] = true;        //记x已在P中
            generateP(index+1);     //处理排列的index+1位
            hashTable[x] = false;   //已处理完P[idnex]的子问题，还原状态
        }
    }
}
int main(){
    n = 4;
    printf("%d\n",Fibonacci(n));
    generateP(1);
    return 0;
}

n皇后问题，在n*n的棋盘上放置n个皇后，使得这n个皇后两两均不在同一行，同一列，同一对角线，求合法方案数。

如果采用组合数的方式来枚举每一种情况，那么枚举量将超级巨大

如果把n列皇后的行号依次写出，就会是1～n的一个排列，则只需要枚举1～n的排列，查看每个排列对应的放置方案是否合法。

于是可以在全排列的代码基础上进行求解，由于当达到递归边界时表示生成了一个排列，所以需要在其内部判断是否为合法方案，

即遍历每两个皇后，判断他们是否在同一条对角线上（不在同一行，同一列是显然的），若不是，则累计计数变量count即可

#include<stdio.h>
#include<math.h>
using namespace std;
/*
    n皇后问题，在n*n的棋盘上放置n个皇后，使得这n个皇后两两均不在同一行，同一列，同一对角线，求合法方案数。
    如果采用组合数的方式来枚举每一种情况，那么枚举量将超级巨大
    如果把n列皇后的行号依次写出，就会是1～n的一个排列，则只需要枚举1～n的排列，查看每个排列对应的放置方案是否合法。
    于是可以在全排列的代码基础上进行求解，由于当达到递归边界时表示生成了一个排列，所以需要在其内部判断是否为合法方案，
    即遍历每两个皇后，判断他们是否在同一条对角线上（不在同一行，同一列是显然的），若不是，则累计计数变量count即可
*/
int count = 0;
const int maxn = 11;
int n,P[maxn],hashTable[maxn] = {false};
void generateP(int index){
    if(index == n+1){
        bool flag  = true;      //flag为true表示当前排列为一个合法方案
        for(int i = 1;i<=n;i++){    //遍历任意两个皇后,由于皇后的列数顺序是固定的（从1～5），全排列的结果是每一列皇后所在的列数
            for(int j = i+1;j<=n;j++){      //从第i列的下一列开始，检查其后每一列皇后所在位置的坐标是否与当前i列皇后所在位置成对角线
                if(abs(i - j) == abs(P[i] - P[j])){         //若成对角线关系，则列数之差一定等于行数之差
                    flag = false;
                }
            }
        }
        if(flag) count++;
        return;
    }

    for(int x = 1;x<=n;x++){
        if(hashTable[x] == false){
            P[index] = x;
            hashTable[x] = true;
            generateP(index+1);
            hashTable[x] = false;
        }
    }
}
int main(){
    n = 8;
    generateP(1);
    printf("%d\n",count);
    return 0;
}