面试算法——排列组合子集一锅端

最新推荐文章于 2021-09-29 17:15:14 发布
最新推荐文章于 2021-09-29 17:15:14 发布
阅读量191 收藏
点赞数 2
分类专栏： 算法 文章标签： 面试算法 排列 组合 子集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29257201/article/details/110671969
版权

文章目录

方法论：

  1. 看题五分钟，不会做，看解析；
  2. 先看中文站，再看国际站；
  3. 选择最优解析；
  4. 回头再来写

面试四步走：

  1. 和面试官，探讨题目限制条件；
  2. 说说可能解，选择最优解；
  3. 码字；
  4. 跑测试用例

思维要点：

  1. 不要人肉进行递归
  2. 找到最近最简方法，将其拆解成可重复解决的问题（重复子问题）
  3. 数学归纳法思维

78.子集

题目：给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

class Solution {
    void generateSub(const vector<int>& nums, vector<vector<int>>& res, vector<int>& path, int start){
        res.push_back(path);
        for( int i = start; i < nums.size(); i++){
            path.push_back(nums[i]);
            generateSub(nums, res, path, i+1 );
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> path; 
        generateSub(nums, res, path, 0);
        return res;
    }
};

90.子集II

题目：给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

# 方法一
class Solution {
    void generateSub(const vector<int>& nums, vector<vector<int>>& res, vector<int>& path, int start){
        res.push_back(path);
        for(int i = start; i < nums.size(); i++){
            if(i > start && nums[i] == nums[i-1])
                continue;
            path.push_back(nums[i]);
            generateSub(nums, res, path, i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> path;
        sort(nums.begin(), nums.end());
        generateSub(nums, res, path, 0);
        return res;
    }
};

# 方法二
class Solution {
    void generateSub(const vector<int>& nums, vector<vector<int>>& res, vector<int>& path, int start){
        res.push_back(path);
        for(int i = start; i < nums.size(); i++){
            path.push_back(nums[i]);
            generateSub(nums, res, path, i+1);
            path.pop_back();
            while (i < nums.size() - 1 && nums[i] == nums[i+1]){
                i++;
            }
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> path;
        sort(nums.begin(), nums.end());
        generateSub(nums, res, path, 0);
        return res;

    }
};

个人倾向于方法2，至于原因，请看Permutations II部分；

46.全排列

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

思路：以下两种方法主要区别是：判断nums[i]是否在path数组中，

  1. 方法1：是通过标记数组used区别；
  2. 方法2：是利用algorithms中的find函数；
# 方法1
class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> path;
        vector<bool> used(nums.size(), false);
        helper(res, nums, path, used);
        return res;
    }

    void helper(vector<vector<int>>& res, vector<int>& nums, vector<int>&path, vector<bool>used) {
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        
        for (int i = 0; i < nums.size(); i++ ){
            if (used[i]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            helper(res, nums, path, used);
            used[i] = false;
            path.pop_back();
        }
    }
};

# 方法2
class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> path;
        helper(res, nums, path);
        return res;
    }

    void helper(vector<vector<int>>& res, vector<int>& nums, vector<int>&path) {
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }

        for (int i = 0; i < nums.size(); i++ ){
            if (find(path.begin(), path.end(), nums[i]) != path.end()) continue;
            path.push_back(nums[i]);
            helper(res, nums, path);
            path.pop_back();
        }
    }
};

47.全排列II

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

思路：

  1. 方法1：当i的值已经在path中或者 i > 0 && nums[i-1] == nums[i] && i-1没有在path中， 忽略该值，这一行代码比较难理解，个人更加倾向于第二种；
  2. 方法2：有兴趣的可以看这个视频：来源 Coding Interview Tutorial 31: Permutations II[LeetCode]
# 方法1
class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> res;
        vector<bool> used = vector<bool>(nums.size(), false);
        vector<int> path;

        sort(nums.begin(), nums.end());
        helper(nums, res, path, used);
        return res;
    }
private:
    void helper(vector<int>& nums, vector<vector<int>>& res, vector<int>& path, vector<bool> used){
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }

        for (int i =0; i < nums.size(); i++){
            if (used[i] || i > 0 && nums[i] == nums[i - 1] && !used[i-1]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            helper(nums, res, path, used);
            path.pop_back();
            used[i] = false;
        }
    }
};

# 方法2
class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> res;
        vector<bool> used = vector<bool>(nums.size(), false);
        vector<int> path;

        sort(nums.begin(), nums.end());
        helper(nums, res, path, used);
        return res;
    }
private:
    void helper(vector<int>& nums, vector<vector<int>>& res, vector<int>& path, vector<bool> used){
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }

        for (int i =0; i < nums.size(); i++){
            if (used[i]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            helper(nums, res, path, used);
            path.pop_back();
            used[i] = false;
            while (i < nums.size() - 1 && nums[i] == nums[i+1]){
                i++;
            }
        }
    }
};

以 nums=[1, 1, 2]说下我的理解：
在这里插入图片描述
跟着蓝色线条的脚步走，还是那句话，不要陷入人肉递归，我们看第一个nums[0] == nums[1]，如果蓝色线条，继续往绿色快走的话，就会出现重复选项，因此需要跳过该块，while(i < nums.size() - 1 && nums[i] = nums[i+1])就是干这个事的；同理，会跳过第二个黄色块；

39.组合总和

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

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> res;
        vector<int> path;
        sort(candidates.begin(), candidates.end());
        helper(candidates, res, path, target, 0);
        return res;
    }

    void helper(vector<int>& candidates, vector<vector<int>>& res, vector<int>& path, int target, int start){
        if (target < 0) return;
        if (target == 0){
            res.push_back(path);
            return;
        }

        for (int i = start; i < candidates.size(); i++){
            path.push_back(candidates[i]);
            helper(candidates, res, path, target - candidates[i], i);	# 元素无限
            path.pop_back();
        }
    }
};

40.组合总和II

题目： 给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

# 方法1
class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int> path;
        vector<vector<int>> res;
        sort(candidates.begin(), candidates.end());
        helper(candidates, res, path, target, 0);
        return res;
    }

    // 时间复杂度O(2^n)  空间复杂度kn
    void helper(vector<int>& candidates, vector<vector<int>>& res, vector<int>& path, int target, int start){
        if (target < 0) return;
        if (target == 0){
            res.push_back(path);   
            return;
        }
        for (int i = start; i < candidates.size(); ++i){
            if (i > start && candidates[i] == candidates[i - 1])    continue;  

            path.push_back(candidates[i]);
            helper(candidates, res, path, target - candidates[i], i + 1);
            path.pop_back();
        }
    }
};

# 方法2
class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int> path;
        vector<vector<int>> res;
        sort(candidates.begin(), candidates.end());
        helper(candidates, res, path, target, 0);
        return res;
    }

    // 时间复杂度O(2^n)  空间复杂度kn
    void helper(vector<int>& candidates, vector<vector<int>>& res, vector<int>& path, int target, int start){
        if (target < 0) return;
        if (target == 0){
            res.push_back(path);   
            return;
        }
        for (int i = start; i < candidates.size(); ++i){
            path.push_back(candidates[i]);
            helper(candidates, res, path, target - candidates[i], i + 1);
            path.pop_back();
            while (i < candidates.size() - 1 && candidates[i] == candidates[i+1]){
                i++;
            }
        }
    }
};

131.分割回文串

题目：给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> res;
        vector<string> path;
        helper(s, res, path, 0);
        return res;
    }

private:
    void helper(string str, vector<vector<string>>& res, vector<string>& path, int start) {
        // terminator
        if (start == str.size()){
            res.push_back(path);
        }

        //string substr (size_t pos = 0, size_t len = npos) const;
        for (int i = start; i < str.size(); i++) {
            if (isPalindrome(str, start, i)){
                path.push_back(str.substr(start, i - start + 1));
                helper(str, res, path, i + 1);
                path.pop_back();
            }
        }
    }

    bool isPalindrome(string str, int start, int end) {
        while(start < end) {
            if (str[start++] != str[end--]){
                return false;
            }
        }
        return true;
    }
};

参考

  1. A general approach to backtracking questions in Java (Subsets, Permutations, Combination Sum, Palindrome Partioning)
  2. Coding Interview Tutorial 31: Permutations II[LeetCode]
  3. leetcode中文站
  4. leetcode国际站 (将力扣中文链接，后面的-cn去掉，就是该题的国际站)
跑酷托托
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排列组合相关笔试面试题（C++）
DjangoBUAA的博客
04-12 2990
一、常考点 含有相同元素的全排列：例如2个a，3个b，4个c可以组成多少个不同的字符串？9!/2!/3!/4!。 n个人的全排列：排成一排为n!，排成一圈且考虑旋转带来的差异也为n!，排成一圈但不考虑旋转差异则为(n-1)!。 二、普通排列组合练习题 1、X*Y的方格阵中，从左上角走到右下角，每次只能走一格且只能向右走或向下走，有多少种走法 解法：向右一定走Y-1步，向下一定走X-1步，
[经典面试题]排列组合专题
weixin_34161083的博客
02-28 227
[LeetCode]31.NextPermutation [LeetCode]46.Permutations [LeetCode]47.Permutations II STL系列之十 全排列(百度迅雷笔试题) [LeetCode]77.Combinations [LeetCode]39.Combination Sum [LeetCod...
一个经典的排列组合面试题目
weixin_30621959的博客
08-22 221
有一个关于排列组合的经典面试题目，拿来分析一下。 题目如下： 1、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列， 如：512234、412345等.要求："4"不能在第三位，"3"与"5"不能相连. 第一种解决思路。 列出所有的组合，然后看看哪个不符合要求，剔除。 对于计算机来说。这种方是可行的，而且思路清晰。 public class test1 ...
程序员面试金典 - 面试题 08.07. 无重复字符串的排列组合（回溯）
Michael是个半路程序员
03-27 1662
1. 题目 无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。 示例1: 输入：S = "qwe" 输出：["qwe", "qew", "wqe", "weq", "ewq", "eqw"] 示例2: 输入：S = "ab" 输出：["ab", "ba"] 提示: 字符都是英文字母。 字符串长度在[1, 9]之间。 来源：力扣（LeetCo...
面试试题 一 (排列组合)
weixin_30851409的博客
07-28 93
昨天有个同学去面试了，回来讨论关于面试的题，因为是提前批次的，所以有点难，有点绕，自己写总结了一下： 1.此题是有关24点游戏,(整体的实现在http://www.cnblogs.com/liuamin/p/6947028.html)，其中用到了递归，比较重要的知识点是排列组合，针对此题，简单说就是4（n）个元素，按不同的排列组合方式，有4！（n! 也就是A(n,n)）种方式。都说迭代的人，递归...
iOS中排列组合算法的使用小结
01-04
最近在项目中用到了排列组合计算，虽然比较简单，但是整个学习过程还是要记录下来的，以便以后可以吸取经验。 一般来说，排列组合就等于搜索。 注意点： 1.去重复：规定子集顺序必须升序； 2.候选数组的结果处理...
zyq2652192993zyq#Advance-Algorithm#基础算法——生成子集与集合运算1
07-25
第二种写法：比如一个数字的二进制表示为：1001110，则比当前数字大的最接近的一个数字是：从末尾开始寻找第一组连续的1将这组连续的1的最高位的1右移一位 10
详解C#的排列组合
09-01
在C#编程中，排列组合是解决许多问题的关键算法，特别是在数据处理、路径规划和决策分析等场景。本文将深入探讨排列与组合的概念，并展示如何使用C#来实现这两种算法。 首先，理解排列和组合的基本定义： 1. 排列...
java数组排列组合问题汇总
08-28
在java数组排列组合问题的应用中，我们可以将其应用于面试或笔试中，多次遇到以下四个关于排列组合的手撕算法，可以用统一的模板实现，如下所示： * 无重复元素的数组，求组合 * 有重复元素的数组，求组合 * 无重复...
Python列表list排列组合操作示例
09-19
本文将深入探讨如何在Python中对列表进行排列组合操作，这些操作对于数据分析、算法设计以及解决各种复杂问题都非常有用。 首先，我们要理解排列和组合的概念。在数学中，排列是有序的选择，而组合是无序的选择。在...
排列组合概率常见面试题
Breadcrumb Trails
07-16 926
排列组合 public class BaseDemo { /** * 在 XxY 的方格中，以左上角格子为起点，右下角格子为终点， * 每次只能向下走或者向右走，请问一共有多少种不同的走法 * 给定两个正整数 int x,int y，请返回走法数目。保证 x＋y 小于等于 12。 */ public int countWays(int x,...
【笔试/面试】排列组合与概率计算（二）
03-25 3245
基本公式 （1）排列Amn=(n−m)!n! A_n^m=\frac{(n-m)!}{n!} （2）组合(nm)=n!m!(n−m)! \binom nm=\frac{n!}{m!(n-m)!} （3）排列组合的关系Amn=m!Cmn A_n^m=m!C_n^m bootstrap 抽样对 NN 个样本进行 bootstrap 抽样（又放回抽样）NN 次，则抽样构成的 NN 个数据
面试题 08.07. 无重复字符串的排列组合
7zwang的博客
09-29 114
面试题 08.07. 无重复字符串的排列组合
程序员面试金典 - 面试题 08.07. 无重复字符串的排列组合
随便发挥的博客
07-24 166
题目难度: 中等 原题链接 今天继续更新程序员面试金典系列, 大家在公众号 算法精选 里回复 面试金典 就能看到该系列当前连载的所有文章了, 记得关注哦~ 题目描述 无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。 示例 1: 输入：S = “qwe” 输出：[“qwe”, “qew”, “wqe”, “weq”, “ewq”, “eqw”] 示例 2: 输入：S = “ab” 输出：[“ab”, “ba”] 提示: 字符都是英文字母。 字符串.
幂集问题（即求全组合，全部子集问题）
qq_34581491的博客
11-30 1418
8、若S是n个元素的集合，则S的幂集P(S)定义为S的所有子集的集合。例如，S=(a,b,c),P(S)={(),(a),(b),(c),(a,b),(a,c),(b,c),(a,b,c)}。给定S，写一递归算法求P(S)。（本题20分） #include #include // 《数据结构》严蔚敏P150 例6.3 void PrintPowerSet(int i, int n) {
【概率论与数理统计】-排列组合笔试题汇总
Gamedev
12-08 2648
位置排列问题随机分配问题像这种相同的物品分给多个人，这一类的问题 直接用隔板法，在物品队列插入隔板，分成多份。最坏情况穷举问题像这种问最多隔多少分钟或者取多少次能到达目的的题目，直接把最坏的结果穷举出来，即可算出最坏时间复杂度。排列相邻与不相邻问题像这种求A与B不相邻的排列情况，可以换成： [两者不相邻的排列情况] = [总排序结果] - [两者相邻的情况]，其中两者相邻就可以看作一个元素X2，因
常见的排列组合问题
shijuan0123的博客
07-22 6037
1.在6*9的方格中，以左上角为起点，右下角为终点，每次只能向下或向右走，请问一共有多少种不同的走法。  一共要走13步，其中必然有5步向下，8步向右。那么就是从13步中选5步向下或者从13步中选出8步向右，则共有种。 2.ABCDEFG七人战队，要求A必须在B的左边，但不一定相邻，请问有多少种排法？如果A必须在B的左边，并且一定要相邻，请问一共有多少种排法？ 不相邻： 7人全排列
全网最详细的排列组合系列算法题整理
极客不撩妹
03-27 3166
写在前面 LeetCode上面排列组合系列几乎所有题目放在一起整理了一下。 面试题 08.07. 无重复字符串的排列组合 无重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合，字符串每个字符均不相同。 示例: 输入：S = “qwe” 输出：[“qwe”, “qew”, “wqe”, “weq”, “ewq”, “eqw”] 提示: 字符都是英文字母。 字符串长度在[1, ...
数据挖掘十大经典算法——C4.5
最新发布
05-19
C4.5算法是决策树学习算法中的一种，是Ross Quinlan于1993年提出的，是ID3算法的改进版。C4.5算法与ID3算法的不同在于，C4.5算法使用信息增益比来选择最佳分类属性，避免了ID3算法中可能存在的偏向选择取值较多的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值