排列组合问题

排列组合问题

组合问题

组合问题即 n 个数进行组合，在这 n 个数中可能重复，也可能重复，因此具体分为两大类组合问题。

例 ：

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

思路

代码

#include<bits/stdc++.h>
using namespace std;

vector<vector<int>> result;
vector<int> path;
void backtracking(int n, int k, int startIndex) {
    if (path.size() == k) {
        result.push_back(path);
        return;
        }
    for (int i = startIndex; i <= n; i++) {
        path.push_back(i);
        backtracking(n,k,i+1);
        path.pop_back();
    }
}
void print() {
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n,k;
    cin >> n >> k;
    backtracking(n,k,1);
    print();
}

代码优化

这个遍历的范围是可以剪枝优化的，怎么优化呢？

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

这么说有点抽象，如图所示：

图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

注意代码中i，就是for循环里选择的起始位置。

for (int i = startIndex; i <= n; i++) {

接下来看一下优化过程如下：

已经选择的元素个数：path.size();

还需要的元素个数为: k - path.size();

在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里大家想不懂的话，建议也举一个例子，就知道是不是要+1了。

所以优化之后的for循环是：

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

优化后代码：

#include<bits/stdc++.h>
using namespace std;

vector<vector<int>> result;
vector<int> path;
void backtracking(int n, int k, int startIndex) {
    if (path.size() == k) {
        result.push_back(path);
        return;
        }
    // i <= n - (k - path.size()) + 1 为剪枝操作
    for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
        path.push_back(i);
        backtracking(n,k,i+1);
        path.pop_back();
    }
}
void print() {
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n,k;
    cin >> n >> k;
    backtracking(n,k,1);
    print();
}

例：

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ]
示例 2： 输入：candidates = [2,3,5], target = 8, 所求解集为： [   [2,2,2,2],   [2,3,3],   [3,5] ]

分析：

代码：

#include<bits/stdc++.h>
using namespace std;
#define vi vector<int>
#define vvi vector<vi>
vvi result;
vi path;
void backtracking(vi& candidates, int sum, int target, int startIndex) {
    if (sum == target) {
        result.push_back(path);
        return;
    }
    for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
        sum += candidates[i];
        path.push_back(candidates[i]);
        backtracking(candidates,sum,target,i);
        sum -= candidates[i];
        path.pop_back();
    }
    return;
}
void print() {
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n,target;
    cin >> n;
    vi candidates;
    for (int i = 0; i < n; i++) {
        int data;
        cin >> data;
        candidates.push_back(data);
    }
    cin >>target;
    sort(candidates.begin(),candidates.end()); // 回溯前先排序！
    backtracking(candidates,0,target,0);
    print();
}

排列问题

例：

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

代码：

#include<bits/stdc++.h>
using namespace std;
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
vvi result;
vi path;
void backtracking(vi& nums, vb& used) {
    if (path.size() == nums.size()) {
        result.push_back(path);
        return;
    }
    for (int i = 0; i < nums.size(); i++) {
        if (used[i]) continue;
        path.push_back(nums[i]);
        used[i] = true;
        backtracking(nums,used);
        path.pop_back();
        used[i] = false;
    }
    return;
}
void print() {
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n;
    cin >> n;
    vi nums;
    for (int i = 0; i < n; i++) {
        int data;
        cin >> data;
        nums.push_back(data);
    }
    vb used(n,false);
    backtracking(nums,used);
    print();
}

例：

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出： [[1,1,2], [1,2,1], [2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

代码：

#include<bits/stdc++.h>
using namespace std;
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
vi path;
vvi result;
void backtracking(vi& nums, vb& used) {
    if (nums.size() == path.size()) {
        result.push_back(path);
        return;
    }
    for (int i = 0; i < nums.size(); i++) {
        if (i > 0 && nums[i] == nums[i-1] && used[i-1] == false) continue;
        if (!used[i]) {
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums,used);
            used[i] = false;
            path.pop_back();
        }
    }
    return;
}
void print() {
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n;
    cin >> n;
    vi nums;
    for (int i = 0; i < n; i++) {
        int data;
        cin >> data;
        nums.push_back(data);
    }
    sort(nums.begin(),nums.end());
    vb used(n,false);
    backtracking(nums,used);
    print();
}

][j] << " ";
        }
        cout << endl;
    }
}
int main() {
    int n;
    cin >> n;
    vi nums;
    for (int i = 0; i < n; i++) {
        int data;
        cin >> data;
        nums.push_back(data);
    }
    sort(nums.begin(),nums.end());
    vb used(n,false);
    backtracking(nums,used);
    print();
}