每日一题 - 剑指 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;
    }
}