【LeetCode】Permutations && Combinations 排列组合

最新推荐文章于 2024-07-12 22:23:23 发布

Snowwolf_Yang

最新推荐文章于 2024-07-12 22:23:23 发布

阅读量1.2k

点赞数

分类专栏： LeetCode 排列组合

本文链接：https://blog.csdn.net/snowwolf_yang/article/details/23754791

版权

LeetCode 同时被 2 个专栏收录

86 篇文章 0 订阅

订阅专栏

排列组合

3 篇文章 0 订阅

订阅专栏

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

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

参考链接

Permutations

http://blog.csdn.net/sunjilong/article/details/8259936

http://blog.csdn.net/doc_sgl/article/details/12290825

http://blog.csdn.net/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.csdn.net/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; }