面试题28：字符串的排列

面试题28：字符串的排列

题目描述：
输入一个字符串，返回该字符串中字符的全排列。
题目分析：
再来看这道题时，分外“眼红”，当年此题竟然没有做出来。
这道题，可以说用分治的思想，将字符串分成两个子问题，子问题1太小不需要再求解，只需要求解子问题2。当然，也可以理解为递归，《算法导论》讲动态规划章节时，有以这种朴素递归为入口来叙述。

1. 递归解法

思路分析1：
递归，将字符串分为两部分，第一个字符和剩余部分的字符串，先确定第一个字符求出对应的全排列，再将第一个字符逐个和后面的字符交换。
该题的关键是：

1. 递归结束的条件；
2. 如果有重复的字符，如何处理，避免交换；

class Solution {
public:
    void Permu(vector<string> &res, string &str, int left) {
    /* string字符串对象也会加'\0'，作为字符串的结尾 */
    if (str[left] == '\0') {
        res.push_back(str);
        return;
    }
    for (int mov = left; str[mov] != '\0'; mov ++) {
        /* 
         * if判断去重，如果是重复字符则不需要交换，
         * 但第一个字符还是要交换的。 
         */
        if (mov == left || str[mov] != str[left]) {
            swap(str[mov], str[left]);
            Permu(res, str, left + 1);
            swap(str[mov], str[left]);
        }
    }
}
    vector<string> Permutation(string str) {
        vector<string> res;
        if (str.length() < 1)
            return res;
        Permu(res, str, 0);
        /* 牛客网要求按字典序输出，所以多加一个排序 */
        sort(res.begin(), res.end());
        return res;
    }
};

2. 非递归解法

思路分析2：
按照字典序排序的思想逐一生成所有序列。
求 p[1…n] 的下一个排列的描述：

1. 求i = max{j | p[j] < p[j + 1]}(找最后一个正序)
2. 求j = max{k | p[i] < p[k]}(找最后一个大于p[i]的p[k])
   （找大于p[i]的是因为小于p[i]的序列都已经求过）
3. 交换 p[i] 与 p[j]得到 p[1] … p[i-1] p[j] p[i+1] … p[j-1] p[i] p[j+1] … p[n]
4. 反转 p[j] 后面的数得到 p[1] … p[i-1] p[j] p[n] … p[j+1] p[i] p[j-1] … p[i+1]

给一个具体的例子来解释上述4步：
求排列8347521的下一个排列：

1. 求i，第一个正序47，i = 3
2. 求j，最后一个大于4的是5，j = 5
3. 交换p[i]和p[j]得，8357421
4. 将p[j]后面的数反转得，8351247

代码如下：

class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string> res;
        int len = str.size();
        if (len == 0)
            return res;
        sort(str.begin(), str.end());
        int i, j;
        while (1) {
            res.push_back(str);
            for (i = len - 2; i >= 0; i --) {
                if (str[i] < str[i + 1]) {
                    for (j = len - 1; j > i; j --)
                        if (str[j] > str[i])
                            break;
                    swap(str[i], str[j]);
                    ReverseStr(str, i + 1, len - 1);
                    break;
                }
            }
            if (i == -1)
                break;
        }
        return res;
    }
    void ReverseStr(string &str, int left, int right) {
        while (left < right) {
            swap(str[left], str[right]);
            ++ left;
            -- right;
        }
    }
};

非递归实现参考：
http://liangjiabin.com/blog/2015/04/leetcode-permutation-generation-algorithm.html （有改动）

3. 该题的引申—康托公式

忘了是XXX公司的笔试题，给定一个字符串S，再给一个字符串T，求字符串T是字符串S是按照字典序输出的第几个字符串。
常规解法：依次求出字符串S的字典序的序列，统计个数，分别和字符串T比较，如果相等，返回统计的个数。
应用康托公式就会简单许多。
但是康托公式展开不能有重复值。

3.1 康托公式和康托展开

康托公式：
X=a[n](n-1)!+a[n-1](n-2)!+…+a[i]*(i-1)!+…+a[1]*0!
其中,a[i]为整数,并且0<= a[i] < i, 1<=i<=n。
康托展开和逆展开：
康托展开是一个全排列到一个自然数的双射，常用于构建哈希表时的空间压缩。 康托展开的实质是计算当前排列在所有由小到大全排列中的顺序，因此是可逆的。

举例解释康托展开的过程：
例如，3 5 7 4 1 2 9 6 8 展开为 94。
因为X=2*8!+3*7!+4*6!+2*5!+0*4!+0*3!+2*2!+0*1!+0*0!=94.

解释：
排列的第一位是3，比3小的数有两个，以这样的数开始的排列有8!个，因此第一项为2*8!
排列的第二位是5，比5小的数有1、2、3、4，由于3已经出现，因此共有3个比5小的数，这样的排列有7!个，因此第二项为3*7!
以此类推，直至0*0!

3.2 康托展开

题目：给定字符串S=“abcdefgh”，任意给定一个字符串S的排列T，求T是S的字典序顺序的第几个排列。
思路分析：根据康托公式计算康托值，从第一位开始s[0]，比s[0]小的有k个，则k * 7!，依次计算得出康托值。
代码如下：

/* 求小于t[i]的字母的个数 */
int Less(string t, int index) {
    int res = 0;
    res = t[index] - 'a';
    if (index == 0) {
        return res;
    } else {
        for (int j = 0; j < index; j ++)
            if (t[j] < t[index])
                -- res;
    }
    return res;
}
int Fib(int n) {
    if (n == 0 || n == 1)
        return 1;
    int f0 = 1;
    int f1 = 1;
    int f2;
    for (int i = 2; i <= n; i ++) {
        f2 = f0 + f1;
        f0 = f1;
        f1 = f2;
    }
    return f2;
}
/* 计算康托值 */
int Cantor(string t, int len) {
    int i;
    int count = 0;
    for (i = 0; i < len; i ++) {
        int val = Less(t, i) * Fib(len - i - 1);
        count += val;
    }
    return count;
}

3.3 康托逆展开

题目：给定字符串S=“abcdefgh”和康托值n，求对应的字符串T。
思路分析：康托展开是一个双射，，自然可以通过康托值求字符串全排列中第n大的排列。
给一个例子就容易理解多了。

如n=5,x=96时：
首先用96-1得到95，说明x之前有95个排列.(将此数本身减去！)
用95去除4! 得到3余23，说明有3个数比第1位小，所以第一位是4.
用23去除3! 得到3余5，说明有3个数比第2位小，所以是4，但是4已出现过，因此是5.
用5去除2!得到2余1，类似地，这一位是3.
用1去除1!得到1余0，这一位是2.
最后一位只能是1.
所以这个数是45321.

参考：
[1] http://www.lxway.com/448528981.htm
[2] http://comzyh.com/blog/archives/92/