剑指Offer：[第28天 搜索与回溯算法(困难)]---＞字符串的排列

---

一、题目描述

输入一个字符串，打印出该字符串中字符的所有排列。你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

示例：

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

限制：

1 <= s 的长度 <= 8

二、思路分析

注：思路分析中的一些内容和图片参考自力扣各位前辈的题解，感谢他们的无私奉献

思路

对于一个长度为 $n$ 的字符串(假设字符互不重复)，其排列方案数共有：$n\times (n-1)\times (n-2)\dots \times 2\times 1$。根据字符串排列的特点，考虑深度优先搜索所有排列方案。即先固定第 $1$ 位字符($n$种排列方案)、再固定第 $2$ 位字符($n-1$种排列方案)、… 、最后固定第 $n$ 位字符($1$种排列方案)。

重复排列方案与剪枝：
当字符串存在重复字符时，排列方案中也存在重复的排列方案。为排除重复方案，需在固定某位字符时，保证每种字符只在此位固定一次，即遇到重复字符时不交换，直接跳过。

递归解析：
①终止条件：当前处理字符的下标 $x=len(list)-1$ 时，代表所有位已固定(最后一位只有 $1$ 种情况)，则将当前组合 $list$ 转化为字符串并加入 $res$，并返回
②递推参数：当前固定位 $x$
③递推工作：初始化一个 $Set$，用于排除重复的字符。将第 $x$ 位字符与 $i\in [x,len(list)]$ 字符分别交换，并进入下层递归
----剪枝：若 $list[i]$ 在 $Set$​ 中，代表其是重复字符，因此剪枝
----将 $list[i]$ 加入 $Set$，以便之后遇到重复字符时剪枝
----固定字符：将字符 $list[i]$ 和 $list[x]$ 交换，即固定 $list[i]$ 为当前位字符
----开启下层递归：调用 $dfs(x+1)$，即开始固定第 $x+1$ 个字符
----还原交换：将字符 $list[i]$ 和 $list[x]$ 交换(还原之前的交换)
交换的含义：
例如，对于字符串 $abc$，基准字符串就是 $abc$，最后的结果应该是$abc,acb,bac,bca,cab,cba$ 。
①第一层第一次循环，有 $a$ 和自己交换，得到 $abc$。进入第二层，$b$ 和自己交换，得到 $abc$。进入最后一层，结束，得到排列 $abc$。
②返回上一层，也就是第二层，$b$ 和 $c$ 交换。进入第三层，结束，得到排列 $acb$。
③返回到第二层，第二层两重循环也已经结束，返回到第一层。
注意：因为没有恢复交换，基准字符串变成了 $acb$，接下来将对 $acb$ 进行交换操作。
④第一层第二次循环，$a$ 和 $c$ 交换，$c$ 没有使用过，得到 $cab$。进入第二层，$a$ 和 $a$ 交换，得到 $cab$。进入最后一层，结束，得到排列 $cab$。
⑤返回上一层，也就是第二层，$a$ 和 $b$ 交换，进入第三层，结束，得到排列 $cba$。
⑥返回到第二层，第二层两重循环也已经结束，返回到第一层。
注意：同样因为没有恢复交换 此时基准字符串变成了 $cba$，接下来对 $cba$ 进行交换操作
⑦第一层第三次循环，$c$ 和 $a$ 交换，但是发现这个 $a$ 我们最开始已经使用过，所以这个分枝就结束了，第三次循环结束。
总结：到此整个调用结束，丢失了两个排列，究其原因就是因为没有恢复字符串，导致基准字符串发生了两次改变。因此每一层调用的基准字符串，都必须恢复原形才能保证完整性，不能中途更换基准字符串。
案例分析：
















复杂度分析：
时间复杂度$\mathrm{O}(\mathrm{N}!\mathrm{N})$：$N$ 为字符串 $s$ 的长度，时间复杂度和字符串排列的方案数成线性关系，方案数为 $N\times (N-1)\times (N-2)\dots \times 2\times 1$，即复杂度为 $O(N!)$，字符串拼接操作使用 $O(N)$，因此总体时间复杂度为 $O(N!N)$
空间复杂度 $\mathrm{O}({\mathrm{N}}^2)$：全排列的递归深度为 $N$，系统累计使用栈空间大小为 $O(N)$，递归中辅助 $Set$ 累计存储的字符数量最多为 $N+(N-1)+...+2+1=(N+1)N/2$，即占用$O(N^2)$的额外空间。

三、整体代码

整体代码如下

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
bool judget(char* s, int start, int end) {
    for (int i = start; i < end; i++) {
        if (s[i] == s[end]) {
            return true;
        }
    }
    return false;
}

void swap(char* s, int left, int right) {
    char tmp = s[left];
    s[left]  = s[right];
    s[right] = tmp;
}

void dfs(char* s, int head, int len, char** res, int* returnSize) {
    /* 当前层递归结束条件，排列只剩下最后一个数字 */
    if (head == len - 1) {
        char* tmp = (char*)malloc(sizeof(char) * (len + 1));
        strcpy(tmp, s);
        res[(*returnSize)++] = tmp;
    }
    /* 依次将当前字符与后面的字符进行交换，并进行下一层递归 */
    for (int i = head; i < len; i++) {
        /* 当前字符s[i]出现过，则跳过 */
        if (judget(s, head, i)) {
            continue;
        }
        /* 回溯 + 递归 */
        swap(s, head, i);
        dfs(s, head + 1, len, res, returnSize);
        swap(s, head, i);
    }
}

char** permutation(char* s, int* returnSize) {
    /* 特判 */
    if (!s) {
        *returnSize = 0;
        return NULL;
    }
    /* 计算返回数组的最大行数 */
    int len = strlen(s);
    *returnSize = 1;
    for (int i = 1; i <= len; i++) {
        (*returnSize) *= i;
    }
    char** res = (char**)malloc(sizeof(char*) * (*returnSize));
    /* 开始递归 */
    *returnSize = 0;
    dfs(s, 0, len, res, returnSize);
    return res;
}

运行，测试通过