排列组合总结

最新推荐文章于 2020-02-09 15:37:33 发布
最新推荐文章于 2020-02-09 15:37:33 发布
阅读量257 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36346463/article/details/79253014
版权

Given a set of distinct integers, return all possible subsets.

Notice
  • Elements in a subset must be in non-descending order.
  • The solution set must not contain duplicate subsets.
Have you met this question in a real interview?
Yes
Example

If S = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

总结点：

  1. make_pair 函数的使用
  2. vector 容器支持pop_back()
  3. 递归和非递归实现，非递归用到队列，模拟二叉树层序遍历


class Solution {
public:
    /*
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        // write your code here
        // ensure order
        sort(nums.begin(), nums.end());
        vector<vector<int> > res;
        // vector<int> result;
        // subsets(nums, 0, result, res);
        subsets(nums, res);
        return res;
    }
    void subsets(vector<int> &nums,
                 int pos,
                 vector<int>& result,
                 vector<vector<int>>& res) {
        res.push_back(result);
        for (int i = pos; i < nums.size(); i++) {
            result.push_back(nums[i]);
            subsets(nums, i + 1, result, res);
            result.pop_back();
        }
    }
    void subsets(vector<int> &nums,
                 vector<vector<int>>& res) {
        queue<pair<int, vector<int>>> subs;
        // init with empty
        res.push_back(vector<int>());
        subs.push(make_pair(-1, vector<int>()));
        // start loop
        while (!subs.empty()) {
            pair<int, vector<int>> tmp = subs.front();
            subs.pop();
            vector<int> result = tmp.second;
            int start = tmp.first + 1;
            for (int i = start; i < nums.size(); i++) {
                result.push_back(nums[i]);
                res.push_back(result);
                subs.push(make_pair(i, result));
                result.pop_back();
            }
        }
    }
};

Given a list of numbers that may has duplicate numbers, return all possible subsets

Notice
  • Each element in a subset must be in non-descending order.
  • The ordering between two subsets is free.
  • The solution set must not contain duplicate subsets.
Have you met this question in a real interview?
Yes
Example

If S = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

class Solution {
public:
    /*
     * @param nums: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    vector<vector<int>> subsetsWithDup(vector<int> &nums) {
        // write your code here
        vector<vector<int>> res;
        // vector<int> result;
        sort(nums.begin(), nums.end());
        // subsets(nums, 0, result, res);
        subsets(nums, res);
        return res;
    }
    void subsets(vector<int> &nums, int pos, vector<int>& result, vector<vector<int>>& res) {
        res.push_back(result);
        for (int i = pos; i < nums.size(); i++) {
            if (i > pos && nums[i] == nums[i - 1]) {
                continue;
            }
            result.push_back(nums[i]);
            subsets(nums, i + 1, result, res);
            result.pop_back();
        }
    }
    void subsets(vector<int>& nums, vector<vector<int>>& res) {
        queue<pair<int, vector<int>>> pairs;
        // init with empty()
        res.push_back(vector<int>());
        pairs.push(make_pair(-1, vector<int>()));
        // loop
        while (!pairs.empty()) {
            pair<int, vector<int>> tmp = pairs.front();
            pairs.pop();
            vector<int> result = tmp.second;
            int start = tmp.first + 1;
            for (int i = start; i < nums.size(); i++) {
                if (i > start && nums[i] == nums[i - 1]) {
                    continue;
                }
                result.push_back(nums[i]);
                res.push_back(result);
                pairs.push(make_pair(i, result));
                result.pop_back();
            }
        }
    }
};

Given a list of numbers, return all possible permutations.

Notice

You can assume that there is no duplicate numbers in the list.

Have you met this question in a real interview?
Yes
Example

For nums = [1,2,3], the permutations are:

[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

点题：

  1. 非递归实现，next permutation算法
  2. 和组合有很大区别，排列用swap
class Solution {
public:
    /*
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    vector<vector<int>> permute(vector<int> &nums) {
        // write your code here
        vector<vector<int>> res;
        //permute(nums, 0, res);
        sort(nums.begin(), nums.end());
        bool is_valid = true;
        while (is_valid) {
            res.push_back(nums);
            is_valid = nextPermute(nums);
        }
        return res;
    }
    void permute(vector<int>& nums, int pos, vector<vector<int>>& res) {
        if (pos == nums.size()) {
            res.push_back(nums);
            return;
        }
        for (int i = pos; i < nums.size(); i++) {
            swap(nums[i], nums[pos]);
            permute(nums, pos + 1, res);
            swap(nums[i], nums[pos]);
        }
    }
    bool nextPermute(vector<int>& nums) {
        int n = nums.size() - 1;
        int m = n - 1;
        while (m >= 0 && nums[m] >= nums[m + 1]) {
            m--;
        }
        if (m >= 0) {
            while (nums[n] <= nums[m]) {
                n--;
            }
            swap(nums[m], nums[n]);
        }
        reverse(nums, m + 1, nums.size() - 1);
        // next permute is valid
        if (m < 0) {
            return false;
        } else {
            return true;
        }
    }
    void reverse(vector<int>& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start++;
            end--;
        }
    }
};

Given a list of numbers with duplicate number in it. Find all unique permutations.

Have you met this question in a real interview?
Yes
Example

For numbers [1,2,2] the unique permutations are:

[
  [1,2,2],
  [2,1,2],
  [2,2,1]
]
点题：
  1. 避免重复的话，next permutation自然避免
  2. 还有其他两种避免办法，一个是swap的时候，在POS上不能出现两次相同的value
  3. 另一个去重算法是一层一层地选，不用swap，用visit标识访问
class Solution {
public:
    /*
     * @param :  A list of integers
     * @return: A list of unique permutations
     */
    vector<vector<int>> permuteUnique(vector<int> &nums) {
        // write your code here
        vector<vector<int>> res;
        vector<int> visit(nums.size(), 0);
        vector<int> result;
        sort(nums.begin(), nums.end());
        // bool is_valid = true;
        // while (is_valid) {
        //     res.push_back(nums);
        //     is_valid = nextPermute(nums);
        // }
        doPermute2(nums, result, visit, res);
        return res;
    }
    void doPermute2(vector<int>& nums, vector<int>& result,
                    vector<int>& visit, vector<vector<int>>& res) {
        if (result.size() == nums.size()) {
            res.push_back(result);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (visit[i] > 0) {
                continue;
            }
            if (i > 0 && nums[i] == nums[i - 1] && visit[i - 1] == 0) {
                continue;
            }
            result.push_back(nums[i]);
            visit[i] = 1;
            doPermute2(nums, result, visit, res);
            visit[i] = 0;
            result.pop_back();
        }
    }
    void doPermute(vector<int>& nums, int pos, vector<vector<int>>& res) {
        if (pos == nums.size()) {
            res.push_back(nums);
            return;
        }
        for (int i = pos; i < nums.size(); i++) {
            if (!needSwap(nums, i, pos)) {
                continue;
            }
            swap(nums[i], nums[pos]);
            doPermute(nums, pos + 1, res);
            swap(nums[i], nums[pos]);
        }
    }
    bool needSwap(vector<int>& nums, int i, int pos) {
        if (i == pos) {
            return true;
        }
        for (int j = pos; j < i; j++) {
            if (nums[j] == nums[i]) {
                return false;
            }
        }
        return true;
    }
    bool nextPermute(vector<int>& nums) {
        int n = nums.size() - 1;
        int m = n - 1;
        while (m >= 0 && nums[m] >= nums[m + 1]) {
            m--;
        }
        if (m >= 0) {
            while (nums[n] <= nums[m]) {
                n--;
            }
            swap(nums[n], nums[m]);
        }
        reverse(nums, m + 1, nums.size() - 1);
        if (m < 0) {
            return false;
        } else {
            return true;
        }
    }
    void reverse(vector<int>& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start++;
            end--;
        }
    }
};

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Notice
  • All numbers (including target) will be positive integers.
  • Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
  • The solution set must not contain duplicate combinations.
Have you met this question in a real interview?
Yes
Example

Given candidate set [2,3,6,7] and target 7, a solution set is: 

[7]
[2, 2, 3]

class Solution {
public:
    /*
     * @param candidates: A list of integers
     * @param target: An integer
     * @return: A list of lists of integers
     */
    vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
        // write your code here
        vector<vector<int>> res;
        vector<int> result;
        sort(candidates.begin(), candidates.end());
        combinationSum(candidates, target, 0, 0, result, res);
        return res;
    }
    void combinationSum(vector<int> &candidates, int target, int sum, int pos,
                        vector<int>& result, vector<vector<int>>& res) {
        if (sum == target) {
            res.push_back(result);
            return;
        }
        for (int i = pos; i < candidates.size(); i++) {
            sum += candidates[i];
            if (sum > target) {
                break;
            }
            result.push_back(candidates[i]);
            combinationSum(candidates, target, sum, i, result, res);
            sum -= candidates[i];
            result.pop_back();
        }
    }
};

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Notice
  • All numbers (including target) will be positive integers.
  • Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
  • The solution set must not contain duplicate combinations.
Have you met this question in a real interview?
Yes
Example

Given candidate set [10,1,6,7,2,1,5] and target 8,

A solution set is: 

[
  [1,7],
  [1,2,5],
  [2,6],
  [1,1,6]
]

class Solution {
public:
    /*
     * @param num: Given the candidate numbers
     * @param target: Given the target number
     * @return: All the combinations that sum to target
     */
    vector<vector<int>> combinationSum2(vector<int> &num, int target) {
        // write your code here
        vector<int> result;
        vector<vector<int>> res;
        sort(num.begin(), num.end());
        combinationSum2(num, target, 0, 0, result, res);
        return res;
    }
    void combinationSum2(vector<int> &num, int target, int sum, int pos,
                         vector<int> &result, vector<vector<int>> &res) {
        if (sum == target) {
            res.push_back(result);
            return;
        }
        for (int i = pos; i < num.size(); i++) {
            if (i > pos && num[i] == num[i - 1]) {
                continue;
            }
            sum += num[i];
            if (sum > target) {
                break;
            }
            result.push_back(num[i]);
            combinationSum2(num, target, sum, i + 1, result, res);
            result.pop_back();
            sum -= num[i];
        }
    }
};

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

Have you met this question in a real interview?
Yes
Example

Given s = "aab", return:

[
  ["aa","b"],
  ["a","a","b"]
]

class Solution {
public:
    /*
     * @param s: A string
     * @return: A list of lists of string
     */
    vector<vector<string>> partition(string &s) {
        // write your code here
        vector<vector<string>> res;
        vector<string> result;
        partition(s, 0, result, res);
        return res;
    }
    void partition(string &s, int pos, vector<string> &result, vector<vector<string>> &res) {
        if (pos == s.size()) {
            res.push_back(result);
            return;
        }
        for (int i = pos; i < s.size(); i++) {
            string tmp = s.substr(pos, i - pos + 1);
            if (isPalindrome(tmp)) {
                result.push_back(tmp);
                partition(s, i + 1, result, res);
                result.pop_back();
            }
        }
    }
    bool isPalindrome(string &s) {
        int i = 0;
        int j = s.size() - 1;
        while (i < j) {
            if (s[i++] != s[j--]) {
                return false;
            }
        }
        return true;
    }
};

Given a digit string excluded 01, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Cellphone

Notice

Although the above answer is in lexicographical order, your answer could be in any order you want.

Have you met this question in a real interview?
Yes
Example

Given "23"

Return ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]

class Solution {
public:
    /*
     * @param digits: A digital string
     * @return: all posible letter combinations
     */
    vector<string> letterCombinations(string &digits) {
        // write your code here
        unordered_map<char, string> maps;
        maps['2'] = "abc";
        maps['3'] = "def";
        maps['4'] = "ghi";
        maps['5'] = "jkl";
        maps['6'] = "mno";
        maps['7'] = "pqrs";
        maps['8'] = "tuv";
        maps['9'] = "wxyz";
        vector<string> res;
        if (digits.size() == 0) {
            return res;
        }
        string result;
        letterCombinations(digits, maps, 0, result, res);
        return res;
    }
    void letterCombinations(string &digits, unordered_map<char, string> &maps,
                            int pos, string &result, vector<string> &res) {
        if (pos == digits.size()) {
            res.push_back(result);
            return;
        }
        string tmp = maps[digits[pos]];
        for (int i = 0; i < tmp.size(); i++) {
            result.push_back(tmp[i]);
            letterCombinations(digits, maps, pos + 1, result, res);
            result.pop_back();
        }
    }
};

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Have you met this question in a real interview?
Yes
Example

Given "25525511135", return

[
  "255.255.11.135",
  "255.255.111.35"
]

Order does not matter.

点题:
  1. IP地址只有四个分割
  2. 每个分割都是小于255
  3. 0开头的数据只能是一个，不能是两个字符

class Solution {
public:
    /*
     * @param s: the IP string
     * @return: All possible valid IP addresses
     */
    vector<string> restoreIpAddresses(string &s) {
        // write your code here
        vector<string> res;
        restoreIpAddresses(s, 0, 4, "", res);
        return res;
    }
    void restoreIpAddresses(string &s, int pos, int k, string result, vector<string> &res) {
        if (pos == s.size() && k == 0) {
            res.push_back(result.substr(1, result.size() - 1));
            return;
        }
        for (int i = pos; i < s.size(); i++) {
            string tmpstr = s.substr(pos, i - pos + 1);
            int tmpint = stoi(tmpstr);
            if (tmpint > 255 || tmpstr[0] == '0' && i > pos) {
                break;
            }
            restoreIpAddresses(s, i + 1, k - 1, result + "." + tmpstr, res);
        }
    }
};


总结：
  1. 非递归实现组合
  2. 非递归实现排列
  3. 递归必须很精通
















chaoai_4278
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排列组合问题总结
dengyan1183的博客
12-06 324
排列组合 根本思想还是组合数学的加法原则，将一个状态分成几个不相交的状态，然后用加法原则加起来即可 1.球同，盒不同，无空箱 如果：n>=m C(n−1,m−1)C(n-1,m-1)C(n−1,m−1) 否则 n<m 000 分析 : 使用插板法：n个球中间有n-1个间隙，现在要分成m个盒子，而且不能有空箱子，所以...
排列和组合相关问题总结
高冲的博客
01-02 541
目录 一、全排列问题 二、组合问题 三、排列、组合问题的变种   一、全排列问题     1.c++标准库函数next_permunation     算法原理：利用字典序进行排序     第一步：从右往左，找到第一个升序位置i，为x；     第二步：从位置i+1开始，找到第一个大于i元素的位置，记为j，为y；     第三步：交换i和j的元素，记交换x和y；     第四...
排列组合总结:将结果进行输出的实现方法
09-05
排列组合是离散数学中的基本概念，用于计算在一定条件下选取对象的方法数量。在计算机科学中，排列组合问题常用于解决各种优化问题、数据分析和算法设计。本文将深入探讨如何实现排列组合的结果输出。 首先，全排列...
组合_排列组合_
10-02
总结来说，排列组合是编程中重要的数学工具，全排列算法模板是通过递归方法实现的，而全局数组则用于存储和展示所有可能的排列。同时，这个问题的讨论也关联到了八皇后问题，展示了排列组合在解决实际问题中的应用。...
新建文本文档_排列组合_源码
10-02
在IT领域，尤其是在编程和算法...总结来说，排列组合在IT中有着广泛的应用，如算法设计、数据结构、图论等。理解并熟练运用排列组合原理，可以帮助我们更有效地解决许多计算问题，包括本例中的生成所有可能的三位数。
关于各种排列组合java算法实现方法
09-05
总结来说，Java中实现排列组合算法主要有两种策略：二进制状态法和递归。二进制状态法适合小规模数据，但效率较低；递归方法虽然直观，但可能导致性能问题。在实际应用中，应根据数据规模和性能需求选择合适的方法。...
排列组合之题目-编程、分水果、竞赛
08-06
总结来说，排列组合在编程、分水果和竞赛中的应用体现了其在实际问题解决中的广泛性和灵活性。通过理解并掌握排列组合的基本原理和算法，我们可以有效地解决这些问题，并在实际编程中实现高效的代码。无论是递归还是...
排列组合的一个问题
12-26
一个长度为N的排列，由数字1-N组成，它满足两个条件： 1.数字1永远在第一位， 2.任意两个相邻数之差小于等于2。 现在给出一个N，你知道能组成多少个符合条件的排列吗？ 例如： n=4 1 2 3 4 1 2 4 3 1 3 2 4 1 3 4 2 所有答案为4.
排列组合典型题目
07-05
很多企业性格测试 包含排列组合和逻辑推理题，提前预备有助于测试中较好的发挥
常用排列组合总结（待续）
Confidence的专栏
02-27 2538
n个物体分成组，每组至少一个物体：隔板法 在n个物体中的n-1个空隙中选取m-1个即可把n个物体分成m组且每组至少一个物体 C(n - 1, m - 1) 情况1的延伸：n个物体分成m组，每组物体数量没有限制（即可以为零） 那么在每组均增加一个物体，即现在有n+m个物体，要分成m组，每组至少一个物体，转变为情况1 C(n + m - 1, m - 1)
13 排列子集总结
weixin_41563161的博客
02-09 324
排列组合总结 子集 给定一组不含重复元素的整数数组nums，返回该数组所有可能的子集（幂集）。 说明：解集不能包含重复的子集。 示例: 输入: nums = [1,2,3] 输出: [[3],[1],[2],[1,2,3],[1,3],[2,3],[1,2],[] ] pu...
排列组合模板小结
u013497977的专栏
04-23 1289
排列组合模板小结
排列组合问题
林竹清_清清清
07-12 479
一、 （1）6*9的方格，左上角起点，右下角终点，请问一共多少种走法？ 共走13步，5步向右8步向下。C513=C813=1287种 public class Robot { public int countWays(int x, int y) { //总共有x+y-2步，其中向右x-1次，向下y-1次 // write code here
python 排列组合
最新发布
09-21
总结来说，Python中的`itertools`模块提供了方便的函数来进行排列组合操作。通过调用`permutations`函数可以进行排列操作，调用`combinations`函数可以进行组合操作。我们可以使用循环来遍历结果，并进行相关的操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值