题目信息
-
时间： 2019-06-29
-
题目链接：Leetcode
-
tag：字符串 深度优先搜索 回溯法
-
难易程度：中等
-
题目描述：
输入一个字符串，打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
示例:
输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]
提示
1 <= s.length() <= 8
解题思路
本题难点
对于一个长度为 n 的字符串（假设字符互不重复），其排列共有 n×(n−1)×(n−2)…×2×1 种方案。要求返回的结果又不能有重复元素。
回溯法 ：一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解的话（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化抛弃该解，即回溯并且再次尝试。
具体思路
这个问题可以看作有 n 个排列成一行的空格，我们需要从左往右依此填入题目给定的 n 个字符，每个字符只能使用一次。
定义chars[]为输入字符串的字符数组，递归函数 backtracking表示从左往右填到第 i 个位置，当前字符串排列为 s。 那么整个递归函数分为两个情况：
- 如果 s.length()==chars.length，说明我们已经填完了 n 个位置（注意下标从 0 开始），找到了一个可行的解，我们将 s 放入答案数组中，递归结束。
- 如果 s.length()<chars.length，我们要考虑这第 i 个位置我们要填哪个字符。根据题目要求我们肯定不能填已经填过的字符，因此很容易想到的一个处理手段是我们定义一个标记数组 hasUsed[] 来标记已经填过的数，那么在填第 i 个数的时候我们遍历题目给定的 n 个字符。
- 如果这个数没有被标记过，我们就尝试填入，并将其标记，继续尝试填下一个位置，即调用函数backtrack。搜索回溯的时候要撤销这一个位置填的数以及标记，并继续尝试其他没被标记过的数。
在一定会产生重复结果集的地方剪枝。
代码
class Solution {
List<String> ret = new ArrayList<>();
public String[] permutation(String s) {
if(s.length() == 0){
return null;
}
// 转换成字符数组
char[] chars = s.toCharArray();
// 排序是为了去重方便
Arrays.sort(chars);
// 由于操作的都是字符，使用 StringBuilder
StringBuilder path = new StringBuilder();
//标记数组。通过标记才能让递归后的代码知道之前用过哪些数据，就可以舍去这些数字（剪枝）。
boolean[] used = new boolean[chars.length];
// 回溯法
backtracking(chars,used,path);
// 记得转成字符串数组
return ret.toArray(new String[ret.size()]);
}
void backtracking(char[] chars,boolean[] hasUsed,StringBuilder s){
// 恰好生成了新的字符对象
if(s.length() == chars.length){
ret.add(s.toString());
return;
}
for(int i = 0; i < chars.length;i++){
if(hasUsed[i]){
continue;
}
//去重，写 !hasUsed[i - 1] 是因为 chars[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
if(i != 0 && chars[i] == chars[i -1] && !hasUsed[i - 1]){
continue;
}
//当前字符是否使用
hasUsed[i] = true;
//将当前字符添加到StringBuilder中
s.append(chars[i]);
//深度优先搜索
backtracking(chars,hasUsed,s);
// 注意：这里是状态重置，是从深层结点回到浅层结点的过程，代码在形式上和递归之前是对称的
// 递归完成以后，需要撤销选择，递归方法执行之前做了什么，递归方法执行以后就需要做相应的逆向操作
s.deleteCharAt(s.length() -1);
hasUsed[i] = false;
}
}
}
复杂度分析：
- 时间复杂度 O(N!) ： N 为字符串 s 的长度；时间复杂度和字符串排列的方案数成线性关系，方案数为 N×(N−1)×(N−2)…×2×1 ，因此复杂度为 O(N!) 。
- 空间复杂度 O(N) ： 其中 n 为序列的长度。除答案数组以外，递归函数在递归过程中需要为每一层递归函数分配栈空间，所以这里需要额外的空间且该空间取决于递归的深度，这里可知递归调用深度为 O(n)。
其他优秀解答
解题思路
-
排列方案的生成方法：根据字符串排列的特点，考虑深度优先搜索所有排列方案。即通过字符交换，先固定第 1 位字符（ n 种情况）、再固定第 2 位字符（ n−1 种情况）、... 、最后固定第 n 位字符（ 1 种情况）。
-
重复方案与剪枝：
当字符串存在重复字符时，排列方案中也存在重复方案。为排除重复方案，需在固定某位字符时，保证 “每种字符只在此位固定一次” ，即遇到重复字符时不交换，直接跳过。从 DFS 角度看，此操作称为 “剪枝” 。
代码
public class Exam38_permutation {
List<String> list = new ArrayList<>();
//为了让递归函数添加结果方便，定义到函数之外，这样无需带到递归函数的参数列表中
char[] c;
//同；但是其赋值依赖c，定义声明分开
public String[] permutation(String s) {
c = s.toCharArray();
//从第一层开始递归
dfs(0);
return list.toArray(new String[list.size()]);
//将字符串数组ArrayList转化为String类型数组
}
private void dfs(int x) {
//当递归函数到达第三层，就返回，因为此时第二第三个位置已经发生了交换
if (x == c.length - 1) {
list.add(String.valueOf(c));//将字符数组转换为字符串
return;
}
//为了防止同一层递归出现重复元素
HashSet<Character> set = new HashSet<>();
//这里就很巧妙了,第一层可以是a,b,c那么就有三种情况，这里i = x,正巧dfs(0)，正好i = 0开始
// 当第二层只有两种情况，dfs(1）i = 1开始
for (int i = x; i < c.length; i++){
//发生剪枝，当包含这个元素的时候，直接跳过
if (set.contains(c[i])){
continue;
}
set.add(c[i]);
//交换元素，这里很是巧妙，当在第二层dfs(1),x = 1,那么i = 1或者 2， 要不是交换1和1，要不交换1和2
swap(i,x);
//进入下一层递归
dfs(x + 1);
//返回时交换回来，这样保证到达第1层的时候，一直都是abc。这里捋顺一下，开始一直都是abc，那么第一位置总共就3个位置
//分别是a与a交换，这个就相当于 x = 0, i = 0;
// a与b交换 x = 0, i = 1;
// a与c交换 x = 0, i = 2;
//就相当于上图中开始的三条路径
//第一个元素固定后，每个引出两条路径,
// b与b交换 x = 1, i = 1;
// b与c交换 x = 1, i = 2;
//所以，结合上图，在每条路径上标注上i的值，就会非常容易好理解了
swap(i,x);
}
}
private void swap(int i, int x) {
char temp = c[i];
c[i] = c[x];
c[x] = temp;
}
}