3.18-3.19算法学习内容

组合总和问题总结

算法一：

这个答案是求排序种类

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>> result;
vector<int> path;
int sum = 0;
void backtracking(vector<int>& nums, int target){
    if(sum > target){
        return ;
    }
    if(sum == target){
        result.push_back(path);
        return ;
    }
    for(int i = 0; i < nums.size(); i++){
        path.push_back(nums[i]);
        sum += nums[i];
        backtracking(nums, target);
        sum -= nums[i];
        path.pop_back();
    }
}
int main(){
    vector<int> nums;
    int n ; cin >> n;
    for(int j = 0 ; j < n ; j++){
        int num ; cin >> num;
        nums.push_back(num);
    }
    backtracking(nums, 10);
    for(vector<vector<int>>::iterator it = result.begin(); 
        it!=result.end(); it++){
            for(vector<int>::iterator vit = (*it).begin(); 
                vit!=(*it).end(); vit++){
                    cout << (*vit) << " ";
            }
            cout << endl;
    }

    return 0;
}

算法二：

这个答案是求组合没有重复使用的元素

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>> result;
vector<int> path;
int sum = 0;
void backtracking(vector<int>& nums, int target, int startIndex){
    if(sum > target){
        return ;
    }
    if(sum == target){
        result.push_back(path);
        return ;
    }
    for(int i = startIndex; i < nums.size(); i++){
        path.push_back(nums[i]);
        sum += nums[i];
        backtracking(nums, target, i+1);
        // backtracking(nums, target, i);
        // 这么写的话是可以出现重复的元素哦
        sum -= nums[i];
        path.pop_back();
    }
}
int main(){
    vector<int> nums;
    int n ; cin >> n;
    for(int j = 0 ; j < n ; j++){
        int num ; cin >> num;
        nums.push_back(num);
    }
    backtracking(nums, 10, 0);
    for(vector<vector<int>>::iterator it = result.begin(); 
        it!=result.end(); it++){
            for(vector<int>::iterator vit = (*it).begin(); 
                vit!=(*it).end(); vit++){
                    cout << (*vit) << " ";
            }
            cout << endl;
    }

    return 0;
}

对代码进行剪枝

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

组合总和二

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, 
    int startIndex, vector<bool>& used){
        if(sum == target){
            result.push_back(path);
            return ;
        }
        for(int i = startIndex; i < candidates.size()
            && sum + candidates[i]<=target; i++){
                // used[i - 1] == true，说明同⼀树⽀candidates[i - 1]使⽤过
                // used[i - 1] == false，说明同⼀树层candidates[i - 1]使⽤过
                // 要对同⼀树层使⽤过的元素进⾏跳过
                if(i > 0 && candidates[i] == candidates[i-1] 
                    && used[i-1]==false){
                        continue;
                }
                sum += candidates[i];
                path.push_back(candidates[i]);
                used[i] = true;
                backtracking(candidates, target, sum, i+1, used);
                // i+1代表每个元素只能用一次哦
                used[i] = false;
                sum -= candidates[i];
                path.pop_back();
        }
}
int main(){
    vector<int> candidates;
    cout << "请输入你要填入candidates里面的数字个数哦" << endl;
    int n ; cin >> n;
    for(int j = 0 ; j < n ; j++){
        int num ; cin >> num;
        candidates.push_back(num);
    }
    cout << "请输入你要的target哦" << endl;
    int target ; cin >> target;
    vector<bool> used(candidates.size(), false);
    path.clear(); result.clear();
    // 首先把给的candidates排序一下，让其相同的元素挨在一起。
    sort(candidates.begin(), candidates.end());
    backtracking(candidates, target, 0, 0, used);
    for(vector<vector<int>>::iterator it = result.begin(); 
        it!=result.end(); it++){
            for(vector<int>::iterator vit = (*it).begin(); 
                vit!=(*it).end(); vit++){
                    cout << (*vit) << " ";
            }
            cout << endl;
    }
    return 0;
}

递增子序列

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex){
    if(path.size() >= 2){
        result.push_back(path);
        // return;      这一块不能return；因为要取到全部的子序列
    }
    // 设立一个uset容器来存放已经放过的数
    unordered_set<int> uset;
    for(int j = startIndex; j < nums.size(); j++){
        if((!path.empty() && nums[j] < path.back()) 
            || uset.find(nums[j]) != uset.end()){
                // path不为空+递减||已经放过的数
                continue;
            }
        // 每放一个数就记录到uset里面去
        uset.insert(nums[j]);
        path.push_back(nums[j]);
        backtracking(nums, j+1);
        path.pop_back();
        // 最后面没有对uset回溯原因是每一次新的循环都会
        // 再建立一个新的并且和上一个uset名字一样的容器
    }
}
int main(){
    vector<int> nums;
    int n ; cin >> n;
    for(int i = 0 ; i < n ; i++){
        int num ; cin >> num;
        nums.push_back(num);
    }
    // 不能对nums容器进行排序，不然最后的结果就发生变化啦
    // sort(nums.begin(), nums.end());
    backtracking(nums, 0);
    for(vector<vector<int>>::iterator it = result.begin(); 
        it!=result.end(); it++){
            for(vector<int>::iterator vit = (*it).begin(); 
                vit!=(*it).end(); vit++){
                    cout << (*vit) << " ";
            }
            cout << endl;
    }
    return 0;
}