全排列问题（详解+题目）

本来想出篇题解，但是咱们先把全排列问题讲一下，再来看题。

一、问题特点
给出一个数组，返回所有可能的全排列。其中“全排列”的定义如下：

将n个元素按照一定的顺序排列起来，所有的排列情况的集合叫全排列

全排列问题的整体思路和其他回溯问题相仿，但去重操作和其他问题有所不同，这是由其自身性质决定的：

排列问题中每一条路径都必须遍历原集合中所有的元素（终止条件恒为 path.size() == nums.size() ）
排列问题中每一种状态中元素的排列顺序必须各不相同
任何一条路径都不能重复遍历同一个元素
二、遍历方法
因为不能使用startIndex修剪搜索空间，每层遍历都要从nums[0]遍历到nums[nums.size()-1]。
路径中的状态不需要记录到结果数组中，终止条件恒为 path.size() == nums.size()

三、去重方法
1.树枝去重
原理
由于同一条路径不能重复取同一个元素，所以必须进行树枝去重。在以往的组合、切割和子集问题中，我们通过使用startIndex限制剩余树枝的搜索空间来完成对同一树枝上元素的去重，但这种去重方法将压减右侧树枝的深度，导致除最左侧树枝以外的所有树枝无法满足路径长度等于原集合大小的条件。此外，这种去重方法也忽视了排列问题解的有序性（例：若原集合为[7, 1]，则解集中[7, 1] 和[1, 7]将无法同时出现，因为当右边的树枝取到1时，它以下的路径的取值范围已经变成了[],元素7已被剪除）
为了进行树枝去重并保证每一条路径都能取到所有元素，需要建立一个数组visited[]存储每一路径中各个元素被使用的情况。

visited[i] == false :说明当前路径上还没有使用过nums[i]，此时左侧路径有可能使用过nums[i]
visited[i] == true :说明当前路径上已经使用过nums[i]，不可重复使用

2.树层去重
原理
使用条件： 原集合中有重复元素
全排列问题对树层的去重操作与组合问题的思路相同
仍然使用visited[]数组去重，但在此之前要先将原集合进行排序，保证所有相同值的元素相邻。然后通过以下语句完成树层去重。

if(i > 0 && nums[i] == nums[i-1] && visited[i-1] == false) {
    // 如果有相同值的上一位元素不是在本树枝上被遍历的，说明在同一层上已被取过，不可重复取值
    continue;
}

四、几种解题方法

一、回溯法
“回溯”指的是“状态重置”，可以理解为“恢复现场”，是在编码的过程中，是为了节约空间而使用的，而在递归或者深度优先中根据需要的场合来配合回溯法可以进一步对自己的代码进行优化。

基本格式：

#include<iostream>
#include<algorithm>
using namespace std;
const int N=10;
bool st[N];//用来判断1~n这n个数是否被选。true代表已经被选了，false反之
int p[N];//用来记录1~n个位置选的是哪个数
int n;
void dfs(int u){
    if(u>n){//当n个位置都确定之后就打印
        for(int i=1;i<=n;i++){
            cout<<p[i]<<" ";
        }
        cout<<endl;
        return;
    }
    for(int i=1;i<=n;i++){//第u个位置开始选数
        if(!st[i]){//如果这个数没有被选
            st[i]=true;//选择这个数打上标记
            p[u]=i;//记录
            dfs(u+1);//开始枚举下一个位置
            st[i]=false;//恢复现场
        }
    }
}
int main()
{
    cin>>n;
    dfs(1);//从第一个位置开始遍历
    return 0;
}

二、字典序法
首先字典序法在数学中就是字典或词典顺序（也称为词汇顺序，字典顺序，字母顺序或词典顺序）是基于字母顺序排列的单词按字母顺序排列的方法
这也就是前面所解释说明的那样，以数组 [1, 2, 3] 的全排列为例。

以 1 开头的全排列为[1, 2, 3], [1, 3, 2]；
以 2 开头的全排列为[2, 1, 3], [2, 3, 1]；
最后以 3 开头的全排列为[3, 1, 2], [3, 2, 1]；
从上面的全排列可以看出来，开头固定数是从左往右依次增大的

基本格式：

/**
list就是集合R
k 表示list中的开始位置
m 表示list中的结束位置
*/
	static int[] list={1,2,3};
	public static void main(String[] args) {
	 perm(list, 0, list.length-1);
	}
	 public static void perm(int[] list,int k,int m){
	     //产生list中第k到m位置上元素的全排列
		if(k==m){//只剩一个元素的情况下的全排列，也是递归出口
			for(int i=0; i<=m; i++){
				System.out.print(list[i]);
			}
			System.out.println();
            return;
		}else{
			for(int i=k; i<=m; i++){       
				swap(list,k,i);//将第i个元素和该子序列中的第一个元素进行交换
				perm(list,k+1,m);//求解规模为n-1的子问题
				swap(list,k,i);//将它换回
			}
		}
	}
	public static void swap(int[] list,int k,int i){ //进行交换
		int temp = list[k];
		list[k] = list[i];
		list[i] = temp;
	}

三、相邻对换法
邻位对换法是全排列生成算法中的其中一种，它的换位是双向的，通过保存数字的“方向性”来快速得到下一个排列

说明:
1、 每个数有一个移动方向，向左或向右。如果数x的移动方向上最靠近它的数比它要小，那么x是可移动的。初始时序列为{1, 2, 3, …, n-1, n}，方向都为向左。
2、 移动最大数n，直到不能移动为止，每改变一次位置输出一个序列（此时n在最左边或最右边）。
3、 找当前可移动的最大数m。若能找到，移动m，把所有比m大的数的方向置反，返回第2步；若不能找到，算法停止。

---

下面是一道题

全排列问题

题目描述
按照字典序输出自然数 1 到 n 所有不重复的排列，即 n 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入格式
一个整数 n

输出格式
由 1∼n 组成的所有不重复的数字序列，每行一个序列，每个数字保留 5 个场宽。

输入数据 1
3
输出数据 1
    1    2    3
    1    3    2
    2    1    3
    2    3    1
    3    1    2
    3    2    1
提示
1≤n≤9
 

---

下面提供两种解法

解法一：递归

代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int a[15];				//存放数据 
bool vis[15];			//访问数组 
int n;

int dfs(int cnt){					//num为排列的数 
	
	if(cnt==0){								//未排列的个数为0 
		int i;
		for(i=n; i>=1; i--){				//输出 存放在数组中的n个数 
			printf("%5d", a[i]);
		}
		putchar('\n');
		return 0;
	}
	
	int i;
	for(i=1; i<=n; i++){				//每次选1-n中的一个数 
		if(vis[i]) continue;			//这个数已经访问则寻找下一个未被访问的数 
		vis[i]=true;
		a[cnt]=i;						//将未被访问的数加入数组 
		dfs(cnt-1);						//下一个数 
		vis[i]=false;					//访问数组恢复 
	}
	return 0;
}
int main(){
	scanf("%d", &n);
	
	int i;
	for(i=1; i<=n; i++){
		vis[i]=false;
	}
	
	dfs(n);
	return 0;
}

解法二：编写next_permutation函数

函数的思路如下

1    2    3
1    3    2
2    1    3
2    3    1
3    1    2
3    2    1

从中选取第三个全排列

从最后一个数开始寻找第一个逆序的数 比如2 3 1

1 3 2 显然 2是第一个逆序的数 标记为start

2   		 3   		 1
start

找到刚好比start的数 也就是3 设置为temp 与他交换位置

3    1    2

最后将start后面的数进行倒置操作

得到

3    1    2

代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

void reverse(int a[], int length, int index){
	int i=index;
	int j=length;
	int temp;
	while(i<=j){
		temp=a[i];
		a[i]=a[j];
		a[j]=temp;
		i++;
		j--;
	}
}

bool next_permutation(int a[], int length){
	int i;
	for(i=length; i>=1; i--){			//从最后一个数开始找到 第一个 不是升序的数 
		if(i-1 == 0) return false;
		if(a[i]>a[i-1]) break;
	}
	
	int start=i-1;						//记录上面找到的数：start 
	while(a[start]<a[i]){				//从start之后找到第一个刚好大于它的数 
		i++;
	}
	
	int temp=a[i-1];					//记录找到的数：temp 将它与之前找到的数：start 交换 
	a[i-1]=a[start];
	a[start]=temp;
	reverse(a, length, start+1);				//将start后面的数倒置 
	return true;
}

int main(){
	int n;
	scanf("%d", &n);
	int a[15]={0};
	int i;
	for(i=1; i<=n; i++){
		a[i]=i;
	}
	
	do{
		for(i=1; i<=n; i++){
			printf("%5d", a[i]);
		}	
		putchar('\n');
	}
	while(next_permutation(a, n));
	
	return 0;
}

给个赞和关注吧