每日一题 - 剑指 Offer 38. 字符串的排列
题目信息
-
时间: 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;
}
}