面试：全排列组合实现

一、全排列

递归暴力DFS：

　　面试中，排列组合的实现是需要掌握的。一般最先想到的方法是暴力循环法，即对于每一位，遍历集合中可能的元素，如果在这一位之前出现过了该元素，跳过该元素。例如对于abc，第一位可以是 a 或 b 或 c 。当第一位为 a 时，第二位再遍历集合，发现 a 不行，因为前面已经出现 a 了，而 b 和 c 可以。当第二位为 b 时 ， 再遍历集合，发现 a 和 b 都不行，c 可以。可以用递归或循环来实现，但是复杂度为 O(nn) 。

void permutation1(string src, string path, vector<string>& res) {
    if (path.size() == src.size()) {
        res.push_back(path);
        return;
    }
    int len = src.length();
    for (int i = 0; i < len; i++) {
        if (path.find(src[i]) == string::npos) {
            path.push_back(src[i]);
            permutation1(src, path, res);
            path.pop_back();
        }
    }
}

vector<string> permutation(string src) {
    vector<string> res;
    permutation1(src, "", res);
    return res;
}

交换：

首先考虑bac和cba这二个字符串是如何得出的。显然这二个都是abc中的 a 与后面两字符交换得到的。然后可以将abc的第二个字符和第三个字符交换得到acb。同理可以根据bac和cba来得bca和cab。因此可以知道 全排列就是从第一个数字起每个数分别与它后面的数字交换，也可以得出这种解法每次得到的结果都是正确结果，所以复杂度为 O(n!)。

void permutation2(string src, int start, vector<string>& res) {
    int n = src.size();
    if (start == n - 1) {
        res.push_back(src);
        return;
    }

    for (int i = start; i < n; i++) {
        std::swap(src[start], src[i]);
        permutation2(src, start + 1, res);
        std::swap(src[start], src[i]);
    }
}

去重的全排列

有时候给出的src中出现重复的字符，类如abb。按照上面的排列方法得出的结果里面会有重复的字符串。为了得到不一样的排列，去重的全排列要从第一个数字起每个数分别与它后面非重复出现的数字交换。用编程的话描述就是第i个数与第j个数交换时，要求[i,j)中没有与第j个数相等的数

void permutation3(string src, int start, vector<string>& res) {
    int n = src.size();
    if (start == n - 1) {
        res.push_back(src);
        return;
    }

    for (int i = start; i < n; i++) {
        bool isRepeated = false;
        for (int j = start; j < i; j++) {
            if (src[j] == src[i]) {
                isRepeated = true;
                break;
            }
        }
        if (!isRepeated) {
            std::swap(src[start], src[i]);
            permutation2(src, start + 1, res);
            std::swap(src[start], src[i]);
        }
    }
}

二、组合

DFS暴力枚举：

void combination2(string src, int start, string path, vector<string>& res) {
    int len = src.length();
    if (start == len) {
        if (!path.empty()) {
            res.push_back(path);
        }
        return;
    }
    combination2(src, start + 1, path, res);
    path.push_back(src[start]);
    combination2(src, start + 1, path, res);
}

vector<string> combination2(string src) {
    if (src.empty())
        return {};
    vector<string> res;
    combination2(src, 0, "", res);
    return res;
}

二进制法：

//二进制法
vector<string> combination(string src) {
    if (src.empty())
        return {};
    int len = src.length();
    int n = 1 << len;
    vector<string> res;
    for (int i = 0; i < n; i++) {
        string tmp;
        for (int j = 0; j < len; j++) {
            if (i & (1 << j)) {
                tmp.push_back(src[j]);
            }
        }
        if (!tmp.empty()) {
            res.push_back(tmp);
        }
    }
    return res;
}