[递归] 子集 全排列和组合问题

最新推荐文章于 2023-12-26 09:00:00 发布
最新推荐文章于 2023-12-26 09:00:00 发布
阅读量188 收藏 2
点赞数 1
分类专栏： C++刷题 文章标签： 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51533157/article/details/132596443
版权

1.1 子集I

思路可以简单概括为 二叉树，每一次分叉要么选择一个元素，要么选择空，总共有n次，因此到n+1进行保存结果，返回。像这样：

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int n;
vector<int >temp;
vector<vector<int> > result;
void DFS(int m){
    if (m == n+1){
        result.push_back(temp);
        return ;
    }

    //选择元素m
    temp.push_back(m);
    DFS(m+1);//继续递归
    temp.pop_back();//返回
    //选择空
    DFS(m+1);
}

bool cmp(vector<int > &a,vector<int > &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    
    scanf("%d",&n);
    DFS(1);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;
}

最后自己编写比较函数，简单来说，vector大小相同时，可以直接按照< >这些比较符号进行比较。大小不同时，则按照vector大小进行排序，这里按照题目要求均是小于。

1.2 子集II

区别在于，自己给定一些元素，进行排序。

那么只需要用一个数组存储这些元素，在压栈/出栈时，换成对应的数组元素即可，思路一致。

代码几乎没有变化。

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> temp;
vector<vector<int> > result;
const int N =15;
int q[N];
int n;
void DFS(int m){
    if (m==n+1){
        result.push_back(temp);
        return ;
    }
    temp.push_back(q[m]);
    DFS(m+1);
    temp.pop_back();
    DFS(m+1);
}
bool cmp(vector<int> &a ,vector<int> &b){
    if (a.size()!= b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    
    scanf("%d",&n);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);
    DFS(1);
    sort(result.begin(),result.end(),cmp);

    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

1.3 子集III

思路还是二叉树深搜递归，但是由于会出现重复的数，按照之前的输出会重复输出一些值，例如样例里的1的子集都会输出两边，因为代码并没有认为第一个1与第二个1是不同的。

首先输入的序列是升序的，因此我们可以连续地处理这些重复的元素。

例如 2 3 3 3 5 

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> temp;
vector<vector<int> > result;
const int N =15;
int q[N];
int n;
void DFS(int idx){
    if (idx==n+1){
        result.push_back(temp);
        return ;
    }
    int cnt=1;
    while (idx<n && q[idx]==q[idx+1]){
        cnt++;
        idx++;
    }//经过该循环，idx = 最后一个重复元素的序号，cnt为重复元素的个数

    // 选择空 
    DFS(idx+1);
    //选择重复元素
    for (int i=1;i<=cnt;i++){
        temp.push_back(q[idx]);
        DFS(idx+1);// 选择重复的元素为 1 2 3 ....cnt个
    }
    //在这个循环中，我们将之前添加到 temp 中的元素逐个移除，
    //以回溯到不添加这些重复元素的情况
    for (int i=1;i<=cnt;i++){
        temp.pop_back();
    }
}
bool cmp(vector<int> &a ,vector<int> &b){
    if (a.size()!= b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    
    scanf("%d",&n);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);
    DFS(1);
    sort(result.begin(),result.end(),cmp);

    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

2.1 全排列I

思路很简单，给个图：

 

设置个q[]表示其是否被使用过，依次递归，返回时再赋值0；

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> temp;
vector<vector<int> > result;
int n;
const int N = 10;
int q[N]={0};
void DFS(int m){
    if (m == n+1){
        result.push_back(temp);
    }
    for (int i=1;i<=n;i++){
        if (!q[i]){
            temp.push_back(i);
            q[i]=1;
            DFS(m+1);
            q[i]=0;
            temp.pop_back();
        }

    }

}
bool cmp(vector<int> &a ,vector<int> &b){
    if (a.size()!=a.size())return a.size()<b.size();
    return a<b;
}
int main(){

    scanf("%d",&n);
    DFS(1);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

2.2 全排列II

思路依旧简单，全排列I是用i作为正整数，这次是给定正整数压栈和出栈，q[]来储存输入的数，flag[]来表示其是否被使用过，代码相同

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
int n;
const int N=10;
int q[N];
int flag[N] = {0};
vector<int> temp;
vector<vector<int> > result;
void DFS(int m){
    if (m==n+1){
        result.push_back(temp);
    }
    for (int i=1;i<=n;i++){
        if (!flag[i]){
            temp.push_back(q[i]);
            flag[i]=1;
            DFS(m+1);
            flag[i]=0;
            temp.pop_back();
        }
    }

}
bool cmp(vector<int> &a,vector<int> &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);
    DFS(1);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

2.3 全排列III

如果按照之前的思路，那么样例1会出现大量重复，与子集的解决方法类似，不过是这里是记录每个数的个数，使用cnt[]进行计算，并且每个数只记录一次；

1 1 3 : 只取最后一个重复的id进行记录次数，像这样：cnt[1] = 0 cnt[2]=2 cnt[3] =1

那么全排列就很简单，每次的全排列对于q[i]的数只能用cnt[i]次数。

那么每次for循环

    for (int i=1;i<=n;i++){
        if (cnt[i]){
            temp.push_back(q[i]);
            cnt[i]--;
            DFS(m+1);
            cnt[i]++;
            temp.pop_back();
        }
    }

只能用一次重复的值 

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
int n;
const int N = 10;
int q[N];
int cnt[N]={0};
vector<int> temp;
vector<vector<int> >result;
void DFS(int m){
    if (m==n+1){
        result.push_back(temp);
        return ;
    }
    for (int i=1;i<=n;i++){
        if (cnt[i]){
            temp.push_back(q[i]);
            cnt[i]--;
            DFS(m+1);
            cnt[i]++;
            temp.pop_back();
        }
    }
}
bool cmp(vector<int> &a,vector<int> &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    scanf("%d",&n);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);
    for (int i=1;i<=n;i++){
        int j=i;
        cnt[i]=1;
        while (j<=n && q[j]==q[j+1]){
            cnt[i]++;
            j++;
        }
        i = j;
    }
    DFS(1);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;


}

3.1 组合I

 

和全排列很像，不过全排列是有顺序的（样例中3 4 和4 3在全排列均是有效的），而组合是无序的，因此我们在挑选的时候可以人为地进行有序限制，从而不会重复。

思路与这道递归题类似

[递归] 自然数分解之方案数_慕梅^的博客-CSDN博客

我们保证后一个数要大于前一个这样的要求，那么就可实现组合题。

样例2中 两个数x y 满足（x<y）

那我们的DFS(int m)，m则是后面的数需要大于的序号

DFS(0)可以作为入口

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
int n,k;
const int N = 15;


vector<int> temp;
vector<vector<int> > result;

void DFS(int m){
    if (temp.size()==k){//递归的出口则改为vector <int> temp的大小==k
        result.push_back(temp);
        return ;
    }
    for (int i=m+1;i<=n;i++){
        //循环从 序号m+1开始
        temp.push_back(i);
        DFS(i);//将i作为参数进行下一次的递归
        temp.pop_back();
    }
    return ;

}
bool cmp(vector<int> &a,vector<int> &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    scanf("%d%d",&n,&k);
    DFS(0);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

 3.2 组合II 

需要自己输入序列，思路不变

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
int n,k;
const int N = 15;
int q[N];
vector<int> temp;
vector<vector<int> > result;

void DFS(int m){
    if (temp.size()==k){
        result.push_back(temp);
        return ;
    }
    for (int i=m+1;i<=n;i++){
        temp.push_back(q[i]);
        DFS(i);
        temp.pop_back();
    }
}
bool cmp(vector<int> &a,vector<int> &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);

    DFS(0);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

3.3 组合III

 可以借鉴全排列的思想，使用cnt来进行计数

#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
int n,k;
const int N = 15;
int q[N];
int cnt[N]={0};
vector<int> temp;
vector<vector<int> > result;

void DFS(int m){
    if (temp.size()==k){
        result.push_back(temp);
        return ;
    }
    for (int i=m;i<=n;i++){//i从m开始，因为有重复的元素。
        if (cnt[i]){
            cnt[i]--;
            temp.push_back(q[i]);
            DFS(i);
            cnt[i]++;
            temp.pop_back();
        }
    }
}
bool cmp(vector<int> &a,vector<int> &b){
    if (a.size()!=b.size())return a.size()<b.size();
    return a<b;
}
int main(){
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++)scanf("%d",&q[i]);
    for (int i=1;i<=n;i++){
        int j = i;
        cnt[i] = 1;
        while ((j+1)<=n&&q[j]==q[j+1]){
            cnt[i]++;
            j++;
        }
        i = j;
    }

    DFS(0);
    sort(result.begin(),result.end(),cmp);
    for (int i=0;i<result.size();i++){
        for (int j=0;j<result[i].size();j++){
            if (j==result[i].size()-1)printf("%d",result[i][j]);
            else printf("%d ",result[i][j]);
        }
        printf("\n");
    }
    return 0;

}

不过与前两个组合不同的是

for (int i=m+1;i<=n;i++){

条件因改为

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

 如果不该与，之前的序列都是没有重复的元素，因此可以下一次的序号需要+1以保证大于前面的数，然而这里有重复的元素，因此从m开始。

慕梅^
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全排列算法C语言超简洁
06-10
自己写的基于字符的全排列算法，代码简洁，高效，7位数的全排列都是秒排！用到了广度优先排列，深度优先搜索和几个递归，唯一没完成的是退出时释放内存，呵呵，破解密码时超有用的哟，，
组合，全排列以及子集超详细讲解
qq_60556896的博客
01-01 1947
应该是特别特别宇宙无敌详细的有关排列组合子集的相关解答了，此篇文章汇集了DFS,位运算的相关解法，相信阅读本篇文章的同学们一定会有大大滴收获的！
【leetcode】回溯算法专场，排列/组合/子集问题
一个写湿的程序猿
04-13 754
这子集（元素无重复，不可复选）组合（元素无重复，不可复选）排列（元素无重复，不可复选）子集/组合（元素可重复，不可复选）组合总和 II排列（元素可重复，不可复选）子集/组合（元素无重复，可复选） 无论是排列、组合还是子集问题，简单说就是从序列 nums 中用题目给定的规则，得出若干个元素，主要有以下几种变体： 形式一、元素无重复，不可复选，即 nums 中的元素都是唯一的，每个元素最多只能被使用一次，这也是最基本的形式。 以组合为例，如果输入 nums = [2,3,6,7]，和为 7 的组合应该只有
回溯算法的五类问题：组合、排列、子集、分割、棋盘
m0_56602092的博客
04-06 527
与组合不同的是，排列需要考虑顺序，在剪枝时不能进行顺序性剪枝，只能剪去已使用的元素。用一个boolean数组记录哪些元素已使用。 ### 1. 全排列 **题目简述**：给定一个不含重复数字的数组nums ，返回其所有可能的全排列 **思路**：回溯算法。在路径选择列表剪枝时，组合问题可进行顺序性剪枝，而排列问题只能剪去path已使用过的数据 * 用一个布尔数组标记每个数是否使用过，回溯时删除路径并将对应元素使用标记重置为false * 回溯递归函数参数：（结果集，已选择路径，数组nums和已
深入探讨回溯算法在排列、组合和子集问题中的应用
最新发布
fudaihb的博客
12-26 1168
回溯算法是一种在组合优化问题中被广泛应用的算法。它是一种递归搜索的方法，通过尝试所有可能的选择来解决问题。在解决排列、组合和子集问题时，回溯算法展现出了其强大的优势。
全排列、子集、组合、子序列
qq_1763467007的博客
08-03 1268
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 子集是指给定一组元素，从中选取0个或多个元素组成的集合。对于n个元素的集合，它将包含2^n个不同的子集，包括空集和全集。 全排列（Permutation）：全排列是指给定一组元素，通过交换元素的位置，得到这组元素所有可能的排列方式。假设有n个元素，全排列将产生n!（n的阶乘）种不
基于集合的子集与集合的全排列的相关问题
09-05
在计算机科学中，集合的子集和全排列是两种常见的概念，它们在数据结构、算法设计和问题求解中占有重要地位。本文将详细解释这两个概念及其相关算法。 首先，集合的子集是指从一个给定集合中选择一部分元素（可以为...
全排列算法的非递归实现与递归实现的方法(C++)
09-05
在C++中，我们可以使用非递归和递归两种方法实现全排列算法。 ### 非递归全排列算法 非递归实现的核心思想是通过不断调整已排序的序列，找到下一个更大的排列。算法主要分为以下几步： 1. 找到当前排列中的最小...
Python基于回溯法子集树模板解决全排列问题示例
09-21
在本示例中，我们将探讨如何使用Python的回溯法和子集树模板来解决全排列问题。回溯法是一种试探性的解决问题的方法，它通过尝试逐步构建解决方案，并在发现错误时撤销最近的决策，从而避免无效的探索。 首先，让...
全排列算法的原理和实现代码
09-04
全排列的基本思想是通过递归地处理问题的子集。假设我们有一组数字{1, 2, 3, ..., n}，全排列就是找到所有可能的序列，使得每个数字在每个位置上都出现过一次。如果n=1，全排列就只有自己，即{1}。对于更大的n，我们...
求一组元素的所有子集的递归实现方法
08-23
该资源是求一组元素的所有子集的递归实现方法，代码用c++实现，简单明了而且有详细的说明。这是我自己写的，已经过测试，但难免会有疏漏，如发现有错误请跟我说，一同探讨改正。
排列组合问题_C++_
10-04
5. **位运算**：在解决组合问题时，尤其是涉及子集选择的问题，位运算可以提供高效的方法。通过二进制数表示集合，我们可以快速地进行集合的并、交、差操作，以及判断某个元素是否在子集中。 6. **计数技巧**：掌握...
组合算法/全排列算法/求子集算法
weixin_43281875的博客
10-12 1381
目录写在前面组合 写在前面 组合 从后开始选： class Solution: def combine(self, n: int, k: int) -> List[List[int]]: ans=[] def sub_combine(n,k,lst=[]): #n个数里面选k个，保存在lst里 if(k==0): #已经选完 ans.append([i for i in lst])
回溯算法：排列与组合详解
yumuing‘s blog
04-02 1764
回溯算法，本质上是一种穷举算法，属于暴力搜索算法的一种。它虽然可以使用剪枝进行优化，仍不高效，但却实用。它往往能够解决可以抽象成树形结构的问题，亦可以认为是使用 K 层 for循环实现搜索的问题： 组合问题：按一定规则在 N 个数中找出 K 个数的集合 切割问题：一个字符串按一定规则切割成子串，求子串个数或符合条件的子集 子集问题：在N 个数的集合中，存在按一定规则分割出的符合某些条件的子集 排列问题：N 个数按一定规则全排列，求其排列结果 棋盘问题：N 皇后问题、数独问题、迷宫问题等等 注：组合与全排
【LeetCode题解】组合、子集、排列问题
hxf_fxh的博客
09-24 150
背景 组合、子集、排列问题都是经典的回溯算法，有共同的特点但是也有不一样的实现细节，这篇文章总结自己刷题过程中的经验。 总结 如果数组中没有重复元素 子集、组合问题使用start指针，每一次搜索从start指针后的元素开始搜索，保证不要选取重复的元素。 排列问题使用visit数组，对自身进行标记，每一次搜索从头开始搜索，但是不要选取自身。 如果数组中含有重复元素 这里注意对同一层搜索进行去重，有两种方法。 使用哈希表记录当前层有哪些元素，如果搜索当前层的过程中遇到重复元素，跳过这次搜索。 首先对数组进行排
详细总结组合排列的十余种算法实现
热门推荐
BoCong-Deng的博客
02-10 2万+
目录 •写在前面 •问题引入 •暴力枚举 循环枚举 递归枚举 回溯枚举 •深度优先搜索 前序遍历 中序遍历 后序遍历 •字典序 •二进制位运算 •带重复数字 •总结 •写在前面 排列组合的问题，如果没有合适的算法去解决，时间复杂度会相当的大，毕竟阶乘的时间复杂度不仅让人头大，也让他计算机欲罢不能，而且我们遇到排列组合的相关问题的概率相当的大，所以非常有必要掌握...
全排列算法（无重复数字全排列/有重复数字全排列）/ 组合算法/ 求子集算法
weixin_43281875的博客
05-19 9118
无重复/有重复数字全排列相关算法
回溯：组合、子集、排列 算法总结
niTaoTaoa的博客
08-21 185
for i =startIndex + 1, backtracking i + 1 // 不可重复使用当前元素。for i =startIndex + 1, backtracking i + 1 // 不可重复使用当前元素。for i =startIndex + 1, backtracking i + 1 // 不可重复使用当前元素。//重复解 则 跳过。for i = 0 //全排列。
【算法】回溯法解决排列、组合、子集问题套路总结
人生何事不浮云
04-14 987
对于排列、组合、子集问题，我们可以根据题目的限制条件“元素是否重复”、“是否允许重复选择”，大致的将其分为三类： ①元素无重不可复选，即集合中的元素都是唯一的，每个元素最多只能被使用一次； ②元素可重不可复选，即集合中的元素可以存在重复，每个元素最多只能被使用一次； ③元素无重可复选，即集合中的元素都是唯一的，每个元素可以被使用若干次；
李港的计算机科学实验：递归实现全排列与子集
这篇资源是山东大学计算机科学与技术学院学生李港的一份实验报告，...通过以上分析，我们可以看到，递归算法在解决全排列和子集生成问题中发挥了关键作用，而理解和优化递归算法是提升算法效率和代码质量的重要途径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值