【LeetCode】Permutations && Combinations 排列组合

最新推荐文章于 2025-05-31 21:59:33 发布

Snowwolf_Yang

最新推荐文章于 2025-05-31 21:59:33 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 排列组合

本文链接：https://blog.youkuaiyun.com/snowwolf_yang/article/details/23754791

LeetCode 同时被 2 个专栏收录

86 篇文章

订阅专栏

排列组合

3 篇文章

订阅专栏

本文详细介绍了如何使用C++实现LeetCode中的排列Permutations和组合Combinations问题，通过递归方法解决，并给出了完整的代码实现。同时，推荐了C++的学习资源。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考链接

Permutations

http://blog.youkuaiyun.com/sunjilong/article/details/8259936

http://blog.youkuaiyun.com/doc_sgl/article/details/12290825

http://blog.youkuaiyun.com/algorithmengine/article/details/8263161

Combinations

http://www.cnblogs.com/remlostime/archive/2012/10/29/2744722.html

题目描述

Permutations

Given a collection of numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

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

题目分析

Permutations排列

题目非常简单，就是输出序列的所有排列，另一种形式是以字母的形式出现。

如给出abc

输出

abc acb bac bca cab cba

思路：使用递归

先固定一个数字，求后面的数字的全排列。再依次和第一个交换。

如此递归。

参考代码中一个好的思路就是，把第一个依次与后面的交换，再求剩下的全排列。这样的好处就是可以不用记录哪些是使用过的，哪些是没使用过的。

Combinations组合

和排列思路差不多，先固定一个数字再递归处理其他数字。

代码示例

Permutations排列

#include 
   
    
#include 
    
     
using namespace std;

#if 1
class Solution {
public:
void get(vector
     
       &num, int index, vector
      
       
         > &solution)
	{
		if(index >= num.size())
		{
			solution.push_back(num);
			return;
		}else
			for(int i = index; i < num.size(); i++)
			{
				swap(num[index],num[i]);
				get(num,index+1,solution);
				swap(num[index],num[i]);
			}
	}
	vector
        
         
           > permute(vector
          
            &num) { // Note: The Solution object is instantiated only once. vector
           
            
              > solution; if(num.size()<1)return solution; get(num, 0, solution); return solution; } }; #elif 1 class Solution { public: void internalPermute(vector
             
               &num, int index, vector
              
                &perm, vector
               
                
                  > &result) { int size = num.size(); if (size == index) { result.push_back(perm); } else { for (int i = index; i < size; ++i) { swap(num[index], num[i]); perm.push_back(num[index]); internalPermute(num, index + 1, perm, result); perm.pop_back(); swap(num[index], num[i]); } } } vector
                 
                  
                    > permute(vector
                   
                     &num) { vector
                    
                     
                       > result; vector
                      
                        perm; internalPermute(num, 0, perm, result); return result; } }; #elif 1 class Solution { public: vector
                       
                        
                          > permute(vector
                         
                           &num) { // Start typing your C/C++ solution below // DO NOT write int main() function vector
                          
                           
                             > res; vector
                            
                              rcd; subPermute(res, num, rcd); return res; } void subPermute(vector
                             
                              
                                > &res, vector
                               
                                 &num, vector
                                
                                  &rcd){ if(num.size() == 0){ res.push_back(rcd); return; } for(int i = 0; i < num.size(); ++i){ vector
                                 
                                   temp = num; rcd.push_back(temp[i]); for(int j = i; j < num.size() -1 ;++j){ temp[j] = temp[j+1]; } temp.pop_back(); subPermute(res, temp, rcd); rcd.pop_back(); } } }; #endif void printvec(vector
                                  
                                    A) { for(int i = 0;i
                                   
                                     > A, char *name) { printf("%s\n",name); for(int i = 0;i
                                    
                                      num(A,A+sizeof(A)/sizeof(int)); Solution so; printvecvec(so.permute(num),"ret"); } int main() { test0(); return 0; }

Combinations组合

/*
编译环境CFree 5.0
博客地址：http://blog.youkuaiyun.com/Snowwolf_Yang
*/

#include 
   
    
#include 
    
     
using namespace std;

void printvec(vector
     
       A)
{
	for(int i = 0;i
      
        > A, char *name)
{
	printf("%s\n",name);
	for(int i = 0;i
       
         > combine(int n, int k) {
    	vector
        
         
           > ret; if(n == 0 || k == 0) return ret; if(n == k) { vector
          
            tmp; for(int i = 1;i<=k;i++) tmp.push_back(i); ret.push_back(tmp); //printvecvec(ret,"0"); return ret; } if(k==1) { vector
           
             tmp; for(int i = 1;i<=n;i++) { tmp.push_back(i); ret.push_back(tmp); tmp.clear(); } //printvecvec(ret,"1"); return ret; } ret = combine(n-1, k); //printvecvec(ret,"2"); vector
            
             
               > ret1 = combine(n-1, k-1); for(int i = 0;i
              
                > combine(int n, int k) { vector
               
                
                  > ret; vector
                 
                   tmp(k); combineCore(1,k,1,n,tmp,ret); return ret; } void combineCore(int i,int k,int start,int n, vector
                  
                    &tmp,vector
                   
                    
                      > &ret) { if(i == k+1) { ret.push_back(tmp); return; } for(int j = start;j<=n;j++) { tmp[i-1] = j; combineCore(i+1,k,j+1,n,tmp,ret); } } }; #endif void test0() { Solution so; printvecvec(so.combine(4,2),""); } int main(int argc, char *argv[]) { test0(); return 0; }