儘管排列組合是生活中經常遇到的問題，可在程式設計時，不深入思考或者經驗不足都讓人無從下手。由於排列組合問題總是先取組合再排列，並且單純的排列問題相對簡單，所以本文僅對組合問題的實現進行詳細討論。以在n個數中選取m(0<m<=n)個數為例，問題可分解為：
1. 首先從n個數中選取編號最大的數，然後在剩下的n-1個數裡面選取m-1個數，直到從n-(m-1)個數中選取1個數為止。
2. 從n個數中選取編號次小的一個數，繼續執行1步，直到當前可選編號最大的數為m。
很明顯，上述方法是一個遞迴的過程，也就是說用遞迴的方法可以很乾淨利索地求得所有組合。
下面是遞迴方法的實現：
/// 求從陣列a[1..n]中任選m個元素的所有組合。
/// a[1..n]表示候選集，n為候選集大小，n>=m>0。
/// b[1..M]用來儲存當前組合中的元素(這裡儲存的是元素下標)，
/// 常量M表示滿足條件的一個組合中元素的個數，M=m，這兩個引數僅用來輸出結果。
void combine( int a[], int n, int m,  int b[], const int M )
{ 
 for(int i=n; i>=m; i--)   // 注意這裡的迴圈範圍
 {
  b[m-1] = i - 1;
  if (m > 1)
   combine(a,i-1,m-1,b,M);
  else                     // m == 1, 輸出一個組合
  {   
   for(int j=M-1; j>=0; j--)
    cout << a[b[j]] << " ";
   cout << endl;
  }
 }
}

因為遞迴程式均可以通過引入棧，用回溯轉化為相應的非遞迴程式，所以組合問題又可以用回溯的方法來解決。為了便於理解，我們可以把組合問題化歸為圖的路徑遍歷問題，在n個數中選取m個數的所有組合，相當於在一個這樣的圖中（下面以從1,2,3,4中任選3個數為例說明）求從[1,1]位置出發到達[m,x](m<=x<=n)位置的所有路徑：
1  2  3  4
    2  3  4
        3  4
上圖是擷取n×n右上對角矩陣的前m行構成，如果把矩矩中的每個元素看作圖中的一個節點，我們要求的所有組合就相當於從第一行的第一列元素[1,1]出發，到第三行的任意一列元素作為結束的所有路徑，規定只有相鄰行之間的節點，並且下一行的節點必須處於上一行節點右面才有路徑相連，其他情況都無路徑相通。顯然，任一路徑經過的數字序列就對應一個符合要求的組合。
下面是非遞迴的回溯方法的實現：
/// 求從陣列a[1..n]中任選m個元素的所有組合。
/// a[1..n]表示候選集，m表示一個組合的元素個數。
/// 返回所有組合的總數。
int combine(int a[], int n, int m)
{  
 m = m > n ? n : m;

  order[k]++;                // 在當前位置選擇新的數字
  if(order[k] == n)          // 當前位置已無數字可選，回溯
  {
   order[k--] = 0;
   continue;
  }    
 
  if(k < m)                  // 更新當前位置的下一位置的數字         
  {
   order[++k] = order[k-1];
   continue;
  }
 
  if(k == m)
   flag = true;
 }

 delete[] order;
 return count;
}

下面是測試以上函式的程式：
int main()
{
 const int N = 4;
 const int M = 3;
 int a[N];
 for(int i=0;i<N;i++)
  a[i] = i+1;

 // 回溯方法
 cout << combine(a,N,3) << endl; 

 // 遞迴方法
 int b[M];
 combine(a,N,M,b,M); 

 return 0;
}

由上述分析可知，解決組合問題的通用演算法不外乎遞迴和回溯兩種。在針對具體問題的時候，因為遞迴程式在遞迴層數上的限制，對於大型組合問題而言，遞迴不是一個好的選擇，這種情況下只能採取回溯的方法來解決。

    n個數的全排列問題相對簡單，可以通過交換位置按序列舉來實現。STL提供了求某個序列下一個排列的演算法next_permutation，其演算法原理如下：
1. 從當前序列最尾端開始往前尋找兩個相鄰元素，令前面一個元素為*i，後一個元素為*ii，且滿足*i<*ii；
2. 再次從當前序列末端開始向前掃描，找出第一個大於*i的元素，令為*j（j可能等於ii），將i，j元素對調；
3. 將ii之後（含ii）的所有元素顛倒次序，這樣所得的排列即為當前序列的下一個排列。
其實現程式碼如下：
template <class BidirectionalIterator>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last)
{
  if (first == last) return false;   // 空範圍
  BidirectionalIterator i = first;
  ++i;
  if (i == last) return false;       // 只有一個元素
  i = last;                          // i 指向尾端
  --i;

 for(;;)
 {
  BidirectionalIterator ii = i;
  --i;
  // 以上，鎖定一組（兩個）相鄰元素
  if (*i < *ii)                     // 如果前一個元素小於後一個元素
  { 
   BidirectionalIterator j = last;  // 令 j指向尾端
   while (!(*i < *--j));            // 由尾端往前找，直到遇上比 *i 大的元素
   iter_swap(i, j);                 // 交換 i, j
   reverse(ii, last);               // 將 ii 之後的元素全部逆向重排
   return true;
  }
  if (i == first)                   // 進行至最前面了
  { 
   reverse(first, last);            // 全部逆向重排
   return false;
  }
 }
}

下面程式演示了利用next_permutation來求取某個序列全排列的方法：
int main()
{
 int ia[] = {1,2,3,4};
 vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));

 copy(iv.begin(),iv.end(),ostream_iterator<int>(cout," "));
 cout << endl;
 while(next_permutation(iv.begin(),iv.end()))
 {
  copy(iv.begin(),iv.end(),ostream_iterator<int>(cout," "));
  cout << endl;
 }

 return 0;
}
注意：上面程式中初始序列是按數值的從小到大的順序排列的，如果初始序列無序的話，上面程式只能求出從當前序列開始的後續部分排列，也就是說next_permutation求出的排列是按排列從小到大的順序進行的。

 [email protected]戴維 2006.5  於北京