【LeetCode-剑指Offer】38. 字符串的排列

一、题目

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例:

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

限制：

1 <= s 的长度 <= 8

二、解决

1、DFS

思路：

排列方案数量：对长度为 n 的字符串，排列共有 $n\ast (n-1)\ast (n-2)\ast ...\ast 2\ast 1$ 种方案。

大概过程：根据字符串排列特点，考虑用DFS搜索所有排列方案。先固定第1个（n种情况）字符，再固定第二位（n-1）字符，最后固定第 n 位字符（1种情况）。

重复方案与剪枝：遇到重复字符不交换，直接跳过，如下图所示。

这里再附一下DFS代码模板，参照理解。

public List<Integer> dfs(Node root, int curLayer, List<Integer> result) {
	// 终止条件
    if (root == null || curlayer > n) return result;  // 数据非法
    if (curLayer.val == true) { // 满足条件
	    result.add(xxx);  // xxx: node.val / curlayer / path
    	return result;
    }
    if (canCutBranch()) return result;
	
	visited[root] = true;  // 标记：处理当前顶点，记录为已访问
    for (Node next : root) { // 遍历与当前顶点相邻的所有未访问顶点
        visited[next] = true; 
        result.add(xxx) // 标记更改: 修改result/path/其他
        dfs(next, curLayer + 1, result)
        visited[next] = false; 
        result.remove(xxx) // 恢复更改: 还原result/path/其他
	}
	return result;
}

代码：

class Solution {
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c)); // 添加排列方案
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            if(set.contains(c[i])) continue; // 重复，因此剪枝
            set.add(c[i]);
            swap(i, x); // 交换，将 c[i] 固定在第 x 位 
            dfs(x + 1); // 开启固定第 x + 1 位字符
            swap(i, x); // 恢复交换，然后回到下一次迭代或上轮递归的下次迭代中
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

时间复杂度： $O(n!)$
空间复杂度： $O(n^2)$

添加一些输出，帮助理解：

class Solution {
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c)); // 添加排列方案
            System.out.println("    " +x + "  res:"+res);
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            System.out.println("x:"+x+"  i:"+i+  "  c:"+ String.valueOf(c));
            if(set.contains(c[i])) continue; // 重复，因此剪枝
            set.add(c[i]);
            swap(i, x); // 交换，将 c[i] 固定在第 x 位
            System.out.println( "x:"+x+"  i:"+i+  "  c:"+ String.valueOf(c)+"      set:"+set+ "      res:"+res);
            dfs(x + 1); // 开启固定第 x + 1 位字符
            System.out.println();
            swap(i, x); // 恢复交换
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

// Input
"abc"

// Output
["abc","acb","bac","bca","cba","cab"]

// Process
x:0  i:0  c:abc
x:0  i:0  c:abc      set:[a]      res:[]
x:1  i:1  c:abc
x:1  i:1  c:abc      set:[b]      res:[]
    2  res:[abc]

x:1  i:2  c:abc
x:1  i:2  c:acb      set:[b, c]      res:[abc]
    2  res:[abc, acb]


x:0  i:1  c:abc
x:0  i:1  c:bac      set:[a, b]      res:[abc, acb]
x:1  i:1  c:bac
x:1  i:1  c:bac      set:[a]      res:[abc, acb]
    2  res:[abc, acb, bac]

x:1  i:2  c:bac
x:1  i:2  c:bca      set:[a, c]      res:[abc, acb, bac]
    2  res:[abc, acb, bac, bca]


x:0  i:2  c:abc
x:0  i:2  c:cba      set:[a, b, c]      res:[abc, acb, bac, bca]
x:1  i:1  c:cba
x:1  i:1  c:cba      set:[b]      res:[abc, acb, bac, bca]
    2  res:[abc, acb, bac, bca, cba]

x:1  i:2  c:cba
x:1  i:2  c:cab      set:[a, b]      res:[abc, acb, bac, bca, cba]
    2  res:[abc, acb, bac, bca, cba, cab]


abc acb bac bca cba cab 

三、参考

1、面试题38. 字符串的排列（回溯法，清晰图解）