组合与排列刷题小结C++

最新推荐文章于 2024-09-20 20:16:39 发布

星期二的风

最新推荐文章于 2024-09-20 20:16:39 发布

阅读量275

点赞数

分类专栏： LeetCode刷题文章标签： c++ leetcode

本文链接：https://blog.csdn.net/weixin_44380570/article/details/119850702

版权

LeetCode刷题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文详细介绍了C++实现从LeetCode第一题两数之和出发，逐步扩展到组合总和与排列的多种情况。通过双指针和回溯法，分别解决数组中元素不可重复和可重复取的情况，以及全排列问题，包括有无重复元素的场景。文章深入探讨了算法思想，并给出了多个实例的输出结果。

摘要由CSDN通过智能技术生成

文章目录

组合与排列刷题小结 C++

组合与排列刷题小结 C++

有感于LeetCode第一题（两数之和）的高赞评论：

有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来。

我呢，就从LeetCode第一题开始，逐步增加难度，力求组合总和与排列总和做到举一反三，并将回溯法理解更深一层。

LeetCode第一题题目如下：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

该题简单之处在于：

①每种输入只有一种答案，且组合中只有2个数
②数组中数不能重复取

在此，做一个拓展：

拓展1—组合总和

①所有满足target的组合中只有两个数，返回所有满足条件的组合

②数组中的数不可以重复取

思路：使用双指针思想，一趟就能完事

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>> f(vector<int>& v, int target) {
    vector<int>path(2, 0);
    vector<vector<int>>res;
    int left = 0, right = v.size() - 1;
    while (left < right) {
        if (v[right] > target - v[left]) right--;
        else if (v[right] < target - v[left]) left++;
        else {
            path[0] = v[left];
            path[1] = v[right];
            res.push_back(path);
            left++;
        }
    }
    return res;
}
int main() {
    vector<int>v = { 1,2,3,4,5 };  //使用双指针，数组v必须是有序的，否则会出错
    vector<vector<int>> res = f(v,6);
    for (auto xx : res) {
    	for (auto x : xx) {
    		cout << x << " ";
   		  }
       cout << endl;
    }
    return 0;
}

输出：
1 5
2 4

拓展2—组合总和

①返回所有组合总和

②数组中的数不可以重复取

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>>ans;
vector<int>mypath;

void backtracking(vector<int>& v, int target, int sum, int startIdx) {
    if (sum > target) return;
    if (sum == target) {
        ans.push_back(mypath);
        return;
    }
    for (int i = startIdx; i < v.size(); i++) {
        mypath.push_back(v[i]);
        sum += v[i];
        backtracking(v, target, sum, i+1);
        sum -= v[i];
        mypath.pop_back();
    }
}

int main() {
    vector<int>v = { 1,2,3,4,5 };  //数组v中的数可以重复
    backtracking(v, 6, 0, 0);
    for (auto xx : ans) {
        for (auto x : xx) {
            cout << x << " ";
        }
        cout << endl;
    }
    return 0;
}

输出：

1 2 3
1 5
2 4

拓展3—组合总和

①数组中元素可重复取，返回所有组合总和

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>>ans;
vector<int>mypath;

void backtracking(vector<int>& v, int target, int sum, int startIdx) {
    if (sum > target) return;
    if (sum == target) {
        ans.push_back(mypath);
        return;
    }
    for (int i = startIdx; i < v.size(); i++) {
        mypath.push_back(v[i]);
        sum += v[i];
        backtracking(v, target, sum, i);
        sum -= v[i];
        mypath.pop_back();
    }
}

int main() {
    vector<int>v = { 1,2,3,4,5 };  //数组v中的数可以重复
    backtracking(v, 6, 0, 0);
    for (auto xx : ans) {
        for (auto x : xx) {
            cout << x << " ";
        }
        cout << endl;
    }
    return 0;
}

输出：

1 1 1 1 1 1
1 1 1 1 2
1 1 1 3
1 1 2 2
1 1 4
1 2 3
1 5
2 2 2
2 4
3 3

组合总和—小结

元素不可重复取——>在backtracking(v, target, sum, i+1)

元素可重复取——>在backtracking(v, target, sum, i)

拓展4—排列

例：LeetCode46 全排列 Ⅰ

①返回所有满足条件的排列

②数值中没有重复的元素

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>>ans;
vector<int>mypath;

void backtracking(vector<int>& v, vector<bool>& used, int target, int sum) {
    if (sum > target) return;
    if (sum == target) {
        ans.push_back(mypath);
        return;
    }
    for (int i = 0; i < v.size(); i++) {
        if(used[i]==true) continue;
        used[i] = true;
        mypath.push_back(v[i]);
        sum += v[i];
        backtracking(v, used, target, sum);
        used[i] = false;
        sum -= v[i];
        mypath.pop_back();
    }
}

int main() {
    vector<int>v = { 1,2,3,4,5 };  
    vector<bool>used(v.size(),false);
    backtracking(v,used, 6, 0);
    for (auto xx : ans) {
        for (auto x : xx) {
            cout << x << " ";
        }
        cout << endl;
    }
    return 0;
}

输出：

1 2 3
1 3 2
1 5
2 1 3
2 3 1
2 4
3 2 1
4 2
5 1

//LeetCode46 全排列Ⅰ 代码：
class Solution {
public:
    vector<vector<int>>res;
    vector<int>path;
    vector<vector<int>> permute(vector<int>& nums) {
        res.clear();
        path.clear();
        vector<bool> used((int)nums.size(), false);
        backtracking(nums,used);
        return res;
         
    }
    void backtracking(vector<int>&v, vector<bool> & used) {
        if(path.size() == v.size()){
            res.push_back(path);
            return;
        }
        for(int i=0; i<v.size();i++) {
            if ( used[i] == true ) continue;
            used[i] = true;
            path.push_back(v[i]);
            backtracking(v, used);
            path.pop_back();
            used[i] = false;
        }
    }

};

拓展5—排列

例：LeetCode47 全排列 Ⅱ

①数组中有重复元素

②返回所有不重复的全排列

#include<bits/stdc++.h>
using namespace std;
vector<vector<int>>ans;
vector<int>path;

void backtracking(vector<int>& v, vector<bool>& used, int target, int sum) {
    if (sum > target) return;
    if (sum == target) {
        ans.push_back(path);
        return;
    }
    for (int i = 0; i < v.size(); i++) {
        if(i>0 && v[i]==v[i-1] && used[i-1]==true) continue;
        if(used[i] == false){
            used[i] = true;
            sum += v[i];
            path.push_back(v[i]);
            backtracking(v,used, target, sum);
            used[i] = false;
            sum -= v[i];
            path.pop_back();
        }
    }
}

int main() {
    vector<int>v = { 1,2,3,4,5 };
    vector<bool>used(v.size(),false);
    backtracking(v,used, 6, 0);
    for (auto xx : ans) {
        for (auto x : xx) {
            cout << x << " ";
        }
        cout << endl;
    }
    return 0;
}

输出：

1 2 3
1 3 2
1 5
2 1 3
2 3 1
2 4
3 1 2
3 2 1
4 2
5 1

//LeetCode47 全排列 Ⅱ  代码：
class Solution {
public:
    vector<vector<int>>res;
    vector<int>path;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool>used(nums.size(),false);
        backtracking(nums, used);
        return res;
    }
    void backtracking(vector<int>& v, vector<bool>& used){
        if(path.size()==v.size()){
            res.push_back(path);
            return ;
        }
        for(int i=0; i<v.size();i++){
            if(i>0 && v[i]==v[i-1] && used[i-1]==true) continue;
            if(used[i] == false){
                used[i] = true;
                path.push_back(v[i]);
                backtracking(v, used);
                used[i] = false;
                path.pop_back();
            }
           
        }
    }
};

全排列—小结

①普通全排列

原始数组中的元素无重复，如：

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

关键处：
if(used[i] == true) continue;

②去重的全排列

原始数组中有重复元素，如：

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

关键处：

if(i>0 && v[i]==v[i-1] && used[i-1]==true) continue;
if(used[i] == false){
     ...
 }

星期二的风

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录