[递归 全排列&N皇后]

[递归 全排列&N皇后]

Description

递归求出全排列，如输出1到5的全排列

Code【全排列】

#include <cstdio>

const int maxn=11;
int n,P[maxn]={0};          //P存放已经排进来的数，n即为要求输出1~n的全排列
bool hashTable[maxn]={false};


void generateP(int index){
    if(index == n+1){          //已经排到第n个数了，可以输出了
        for(int i=1;i<=n;i++){
            printf("%d ",P[i]);
        }
        printf("\n");
        return;
    }

    for(int x=1;x<=n;x++){
        if(hashTable[x]==false){
            P[index]=x;         //x不在P中，则放进P，并置位，标记为已放入
            hashTable[x]=true;
            generateP(index+1);
            hashTable[x]=false; //处理完P[index]=x的子问题,下次index的位置该放别人了（还原，让别人来占位）
        }
    }
}


int main(){
    n=5;
    generateP(1); //从1开始，输出1~5的全排列
    return 0;

}

 

Description

递归求出N皇后

N皇后：在nxn的方阵棋盘上摆n个皇后，要求他们中任意两个不同行不同列，不在一条对角线上

Code【N皇后】

思路1：借助上面的求全排列的思想，NxN的棋盘放n个棋子，最终每一行都会放一个，而每个棋子的的列数就构成了一个1~n的排列，以N=5为例，对于一个排列{1,3,2,4,5}，可以理解为：第一行第一列放一个，第二行第三列放一个，第三行第二列放一个，第四行第四列放一个，第五行第五列放一个；这样一个排列就表征了一种可能的放法；

接下来对于产生的全排列逐一check，若不符合要求则舍去：对于同行同列，由于我们一个五个位置（index=1,2,3,4,5）各不相同，排的五个数（1,2,3,4,5）也不相同，所以不可能出现同行同列（比如{1,2,2,3,4}其中有同列，但这不是一个排列，不可能出现）；对于同对角线，利用(abs(i-j) == abs(P[i]-P[j])来判断（斜率为1或者-1的不行）

#include <cstdio>
#include <cmath>
const int maxn=11;
int n,P[maxn]={0};
bool hashTable[maxn]={false};
int count=0;

void generateP(int index){
    if(index == n+1){
        bool flag=true;
        for(int i=1;i<=n;i++){
            for(int j=i+1;j<=n;j++){
                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",count);
    return 0;

}

 

思路2：和上面思路类似，不同的是利用回溯，在做排列的时候就进行判断是否合法，以此提前返回

#include <cstdio>
#include <cmath>
const int maxn=11;
int n,P[maxn]={0};
bool hashTable[maxn]={false};
int count=0;

void generateP(int index){
    if(index == n+1){
        count++;
        return;
    }

    for(int x=1;x<=n;x++){
        if(hashTable[x]==false){    //当前准备在index行放下x
            bool flag=true;
            for(int pre=1;pre<index;pre++){     //需要比较之前的棋子和当前棋子是否矛盾
                if(abs(index-pre)==abs(x-P[pre])){
                    flag=false;
                    break;
                }
            }
            if(flag){
                P[index]=x;
                hashTable[x]=true;
                generateP(index+1);
                hashTable[x]=false;
            }
        }
    }
}


int main(){
    n=8;
    generateP(1);
    printf("%d",count);
    return 0;

}

以上代码COPY自算法笔记。

易错点：

七年了，八皇后对我来说依旧理解起来有难度，或许写代码这行真的不适合我吧。可是不做他，又不知道自己还能干嘛。

在上面全排列的基础上，若要给出m个数中的n个数的组合（无序）的CODE,需要在给P[index+1]赋值时，略过前面已经找过的值

#include <cstdio>
#include <cstring>

const int maxk=10;
int collection[maxk]={0};
int index=0;
bool hash_table[maxk]={0};
int buffer[maxk];
void get_collection(int *buffer,int i,int n,int index,int k){
    if(index==k){
        for(int i=0;i<index;i++)
            printf("%d ",collection[i]);
    printf("\n");
    return;
    }

    for(int s=i;s<n;s++){
        if(hash_table[s]==false){
            collection[index]=buffer[s];
            hash_table[s]=true;
            get_collection(buffer,s+1,n,index+1,k);
            //get_collection(buffer,i,n,index+1,k);
            hash_table[s]=false;
        }
    }
}

int main(){
    int n,k;
    scanf("%d %d",&n,&k);
    for(int i=0;i<n;i++)
        scanf("%d",&buffer[i]);
    get_collection(buffer,0,n,index,k);
    return 0;
}