全排列的递归与非递归形式

2018-3-18

1.递归的主要思路是：
n个数的全排列=（n-1个数的全排列）+（另一个数作为前缀）

#include<iostream>
using namespace std;

const int N = 3;
int x[N+1]={1,2,3};

void dfs(int step,int end){
    if (step==N){
        for (int i=0;i<N;i++){
            cout<<x[i]<<" ";
        }
        cout<<endl;
        return ;
    }
    for (int i=step;i<end;i++){
        int t=x[i];x[i]=x[step];x[step]=t;
        dfs(step+1,end);
        t=x[i];x[i]=x[step];x[step]=t;
    }
}

int main(){
    dfs(0,N); 
    return 0;
} 

2.若我们的序列里面有重复的数字呢？去重的全排列就是从第一个数字开始每个数和它后面非重复出现的数字交换。当然这里的重复出现的数字的最后一个会变成非重复的数字的，因而我们这里保证和相同的数字只交换一次。

#include<iostream>
using namespace std;

const int N = 5;
int x[N+1]={1,2,3,2,1};

bool res(int step,int end){
    for (int i=step+1;i<end;i++){
        if (x[i]==x[step]) return false;
    }
    return true;
}

void dfs(int step,int end){
    if (step==N){
        for (int i=0;i<N;i++){
            cout<<x[i]<<" ";
        }
        cout<<endl;
        return ;
    }
    for (int i=step;i<end;i++){
        if (res(i,end)){
            int t=x[i];x[i]=x[step];x[step]=t;
            dfs(step+1,end);
            t=x[i];x[i]=x[step];x[step]=t;  
        }
    }
}

int main(){
    dfs(0,N); 
    return 0;
} 

3.非递归形式就需要我们找规律了…
下一个序列为从右往左找到第一个x[i]<x[i+1]的那个，然后再从右往左找到第一个比x[i]大的数x[j]，两个数进行交换，交换过后将x[i]之后的所有数进行从小到大排序即可。
上一个序列为从右往左找到第一个x[i]&rt;x[i+1]的那个，然后再从右往左找到第一个比x[i]小的数x[j]，两个数进行交换，交换过后将x[i]之后的所有数进行从大到小排序即可。

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 6;
int x[N+1]={9,2,6,5,2,0};

void next_prime(){
    int i,j; 
    for (i=N-2;i>=0;i--) {
        if (x[i]<x[i+1]){
            break;
        } 
    } 
    for (j=N-1;j>=0;j--){
        if (x[j]>x[i]){
            break;
        }
    }
    int t=x[j];x[j]=x[i];x[i]=t;
    sort(x+i+1,x+N);
}

bool cmp(int a,int b){
    return a>b;
} 

void pre_prime(){
    int i,j; 
    for (i=N-2;i>=0;i--) {
        if (x[i]>x[i+1]){
            break;
        } 
    } 
    for (j=N-1;j>=0;j--){
        if (x[j]<x[i]){
            break;
        }
    }
    int t=x[j];x[j]=x[i];x[i]=t;
    sort(x+i+1,x+N,cmp);
}

void show(){
    for (int i=0;i<N;i++){
        cout<<x[i]; 
    } 
    cout<<endl;
}

int main(){
    next_prime();
    show();
    pre_prime();
    show();
    return 0;
}

给一个题目吧！
搭积木：
一共有0到9共10个积木，每个积木都有一个数字0~9，每个积木放在两个积木上面，但是要满足比下面两个积木小，搭四层的积木，共有多少搭法。

方法一：
将其看作是一维的，利用全排列把所有情况都表示出来然后再进行判断，满足条件就将s+1。

#include<iostream>
using namespace std;

const int N = 10;
int x[N+1]={0,1,2,3,4,5,6,7,8,9};
int s=0;

bool res(){
    if (x[0]>x[1]||x[0]>x[2]) return false;
    if (x[1]>x[3]||x[1]>x[4]) return false;
    if (x[2]>x[4]||x[2]>x[5]) return false;
    if (x[3]>x[6]||x[3]>x[7]) return false;
    if (x[4]>x[7]||x[4]>x[8]) return false;
    if (x[5]>x[8]||x[5]>x[9]) return false;
    return true;
}

void dfs(int step,int end){
    if (step==N){
        if (res()) s++;
        return ;
    }
    for (int i=step;i<end;i++){
        int t=x[i];x[i]=x[step];x[step]=t;
        dfs(step+1,end);
        t=x[i];x[i]=x[step];x[step]=t;
    }
}

int main(){
    dfs(0,N); 
    cout<<s<<endl;
    return 0;
} 

方法二：
将它看成二维的，逐行逐列进行查看，一旦发现x[c][r]<x[c-1][r-1]或者<x[c][r-1]就continue。

#include<iostream>
#include<cstring>
using namespace std;

const int N = 10, M = 4;
bool f[N+1];
int x[N+1][N+1];
int sum=0;

void dfs(int r, int c){
    if (r==M+1){
        sum++;
        return ;
    }
    if (c==r+1){
        dfs(r+1,1);
        return ;
    }
    for (int i=1;i<N;i++){
        if (i<x[r-1][c-1]||i<x[r-1][c]) continue;
        if (!f[i]){
            f[i]=true;
            x[r][c]=i;
            dfs(r,c+1);
            f[i]=false;
        }
    }
}

int main(){
    memset(f,false,sizeof(f));
    dfs(2,1);
    cout<<sum<<endl;
    return 0;
}