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

    }

}

巴特西

每日一题 - 剑指 Offer 38. 字符串的排列

题目信息

解题思路

代码

其他优秀解答

最新文章

热门文章