全排列及相关扩展算法（七）——组合数的字典序（另含全章代码整理）

1.引入概念：要列出一个集合{1,2,3,4}的所有子集是很容易的，我们可以按照二进制数的顺序，0000，0001，0010，0011，0100，0101，0110，0111......来表示我们要取的元素，其中0表示不取，1表示取，这样就获得了一个顺序。而组合也包含在这个顺序当中。我们看从{1,2,3,4}中选取两个元素的所有组合：
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111.

蓝色标记的是我们所取的组合。对应的顺序便是｛3，4｝｛2，4｝｛2，3｝｛1，4｝｛1，3｝｛1，2｝我们可以用字典序对这些组合进行排序：{1,2}{1,3}{1,4}{2,3}{2,4}{3,4}.共6种。按照我的习惯，我们先看看我们平常列举组合数所采取的策略。比如说1，2，3，4，5取3个元素的组合。我们先从小的取：1，2，3.再把最后一个数改变:1,2,4;1,2,5.当到达5之后，含有1，2的所有组合已经被罗列完了。改变2为3，1，3，4；1，3，5；此时我们不能再选择2进行罗列，否则会重复。改变3为4，此时2和3都不能放入，1，4，5.改变4为5时，2，3，4都不能放入，不存在组合了。这时改变1为2。之后不能再选择1罗列。所以:对于一个组合C1C2C3C4...Cr(每个代表一个数，一共r个数，代表一个组合，数从[1,n]中选)，由于一个组合自身是不讲顺序的，我们可以对组合进行升序排列，使得C1<C2<C3<...Cr。一开始我们取最小的元素的组合，并按照字典序把Cr慢慢递增1，这显然是在组合不断取字典序的下一个组合，没有夹杂在这这个方法能取到的值中间的其它组合。在所有组合数当Cr到达n之后，Cr无法变大了，就要做其它的事。由于强制了升序，C(r-1) < Cr ，所以C(r - 1) 到达n-1后也得去做其它的事。

2.性质：

C(r - m)到达n - m后就不能再递增上去。由k = r - (r - k)得到
C(k)到达n - (r - k) = n - r + k 后就不能再递增上去。
那么，对于C1C2C3C4...Cr，我们从Cr开始向前找，直到找到有Ci < n - r + i，并执行
Ci = Ci + 1。由于所有的组合都已经强制升序，所以Cj= Ci + (j-i),j = i+1,i+2,...r即它后面的每一项都比前一项大1。由于Ci< n -r + i，Cr = Ci + (r - i) <=n(因为Ci比原来大了1)，所以构造出来的新的C1C2C3C4...Cr仍是[1,n]中选r个元素的一个组合，而且显然它在原组合的字典序后。 由此，我们构造出了一个排在原组合的字典序后面的组合。接下来证明它是紧邻着原组合的。

3.证明：假设有一个组合B1B2B3B4...Br的前i-1个元素和C1C2C3C4...Cr一样，且在原组合字典序后，在我们构造的字典序前，那么必有新Ci > Bi > 原Ci，这是不可能的，因为新Ci= 原Ci + 1。同样不可能存在前i个元素一样但在新Ci字典序前的组合，因为强制排序后Cj 到Cr 的每个元素都是最小的。同样不可能存在前k个元素一样（k < i）但在新Ci字典序前的组合。

如果找不到有Ci < n - r + i，说明已经到达最后一个：n -r + 1,n - r + 2,...n.由此我们可以直接得到组合数的相对字典序。下一个组合算法代码：

bool Next_Combination(int A[], int n, int r)
{
int i;
sort(A, A + r);
for (i = r - 1; !(A[i] <n - r + i) && i > 0; i--);
if (i == 0)
return false;
A[i] = A[i] + 1;
for (int j = i + 1; j<r; j++)
A[j] = A[i] + j - i;
return true;
}

4.参考文档

https://wenku.baidu.com/view/8c79a2facc17552706220880.html

PS：全章代码整理：

//https://wenku.baidu.com/view/8c79a2facc17552706220880.html

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<windows.h>
#include<math.h>
#include <time.h>  
#include <functional>
using namespace std;
 
int Count = 0;
void Swap(int &a, int &b)
{
a == b ? 0 : a ^= b ^= a ^= b;
}
 
 
void Print(int A[],int n)
{
for (int i = 0; i < n; i++)
{
printf("%d%c", A[i], i == n - 1 ? '\n' : ' ');
}
}
void Permutation(int A[], int m, int n)
{
if (m == n)
{
//Print(A, n);
Count++;
}
else
{
for (int i = m; i < n; i++)
{
Swap(A[m],A[i]);
Permutation(A, m + 1, n);
    Swap(A[m],A[i]);
}
}
}
 
 
 
void Reverse(int A[],int a,int b)
{
while (a < b)
{
Swap(A[a], A[b]);
a++;
b--;
}
}
bool next_permutation(int A[], int n)
{
int i = n - 2;
while ((A[i + 1] <= A[i])&&i>=0)i--;
if (i<0)
{
Reverse(A,0,n-1);
return false;
}
else
{
int j = i+1;
while ((A[j] > A[i])&&j<n)j++;
Swap(A[j-1], A[i]);
Reverse(A ,i+1 , n-1);
return true;
}
}
int factorial(int x) { return x > 1 ? x*factorial(x - 1) : 1; }
 
 
int* get_permutation_medium(int A[], int n)
{
int* temp = new int[n-1];
 
for (int i = 0; i < n-1; i++)
{
temp[i] = 0;
for (int j = i + 1; j <= n - 1; j++)
{
if (A[j] < A[i])
{
temp[i]++;
}
}
}
return temp;
}
 
int get_permutation_rank(int medium[],int n)
{
int rank = 0;
for (int i = 0; i < n - 1;i++)
{
rank += medium[i]* factorial(n - 1 - i);
}
return rank;
}
 
int* get_permutation(int medium[], int n)
{
int* temp = new int[n + 1];
int* permutation = new int[n + 1];
for (int i = 0; i <= n; i++)
{
permutation[i]=temp[i] = i == n ? 1 : medium[i] + 1;
}
 
for (int i = 0; i <= n ; i++)
{
for (int j = i - 1; j >= 0; j--)
{
if (temp[j] <= temp[i])
{
temp[i]++;
permutation[i]++;
}
else
{
break;
}
}
sort(temp,temp + i+1, greater<int>());
}
return permutation;
}
 
 
 
int* get_permutation_error(int medium[], int n)
{
int* temp = new int[n + 1];
for (int i = 0; i <= n; i++)
{
temp[i] = i == n ? 1 : medium[i] + 1;
}
 
for (int i = 0; i <= n; i++)
{
for (int j = i - 1; j >= 0; j--)
{
if ((medium[j] <= (i == n ? 1 : medium[i])) || (temp[j] <= temp[i]))
{
temp[i]++;
}
}
}
return temp;
}
 
 
int* get_permutation_medium_plus(int A[], int n)
{
int* temp = new int[n];
 
for (int i = 0; i < n; i++)
{
temp[n-A[i]] = 0;
for (int j = i + 1; j <= n - 1; j++)
{
if (A[j] < A[i])
{
temp[n-A[i]]++;
}
}
}
 
return temp;
}
 
int get_permutation_rank_plus(int medium[], int n)
{
int rank = 0;
for (int i = 0; i < n-1; i++)
{
rank += medium[i];
rank *= n - i -1;
}
 
return rank;
}
 
int* get_permutation_plus(int medium[], int n)
{
int* temp = new int[n];
memset(temp, 0, n * sizeof(int));
for (int i = 0; i < n; i++)
{
int empty = -1,j=n;//防止末尾已经被占的情况故提前一位
while (empty < medium[i] && j >= 0)
{
j--;
if (temp[j] <= 0)
{
empty++;
}
}
temp[j] = n - i;
}
 
return temp;
}
 
 
 
bool Movable(int A[], bool direct[], int n) //direct参数用于接收每个元素移动方向的数组。
{
int max = 1;//初始化最大可移动数为1，因为规定1是最小的数，可以自己设定。
int pos = -1;//初始化最大可移动数的位置为-1.
/*下面先找到最大可移动数位置*/
for (int i = 0; i<n; i++)
{
if (A[i] < max)
continue;
if ((i < n - 1 && A[i] > A[i + 1] && direct[i]) || (i> 0 && A[i] >A[i - 1] && !direct[i]))
{
max = A[i];
pos = i;
}
}
/*下面对它进行移动*/
if (pos == -1)
return false;
if (direct[pos])
{
swap(A[pos], A[pos + 1]);
swap(direct[pos], direct[pos + 1]);
}
else
{
swap(A[pos], A[pos - 1]);
swap(direct[pos], direct[pos - 1]);
}
 
/*最后调整所有比最大可移动数大的数的方向*/
for (int i = 0; i<n; i++)
{
if (A[i] > max)
direct[i] = !direct[i];
}
return true;
}
void Full_Array(int A[], int n)
{
bool* direct = new bool[n]; //产生一个记录每个元素移动方向的数组
sort(A, A + n); //将原序列变成一个升序
for (int i = 0; i<n; i++)
    direct[i] = false;//初始化移动方向为false，表示从右向左。
do
{
//Print(A, n);
Count++;
if (A[n - 1] == n)
for (int i = n - 1; i>0; i--)
{
swap(A[i], A[i - 1]);
swap(direct[i], direct[i - 1]); 
//Print(A, n);
Count++;
}
else
for (int i = 0; i < n-1; i++)
{
swap(A[i], A[i + 1]);
swap(direct[i], direct[i + 1]);
//Print(A, n);
Count++;
}
} while (Movable(A, direct, n));
delete[]direct;
}
 
 
 
bool Next_Combination(int A[], int n, int r)
{
int i;
sort(A, A + r);
for (i = r - 1; !(A[i] <n - r + i) && i > 0; i--);
if (i == 0)
return false;
A[i] = A[i] + 1;
for (int j = i + 1; j<r; j++)
A[j] = A[i] + j - i;
return true;
}
 
 
int main()
{
//int A[] = { 7,6,8,3,4,5,1,2 };
//int A[] = { 3,6,5,1,2,4,7 };
//int A[] = { 7,6,5,4,3,2,1 };
//int A[] = { 1,2,3,4};
int A[] = { 1,2,3,4,5,6,7,8,9,10,11,12};
int n = sizeof(A) / sizeof(A[0]);
 
//STL模版函数全排列：
time_t t1 = time(NULL);
    while (next_permutation(A, n))Count++;
printf("%d\n", Count); Count = 0;
//邻位对换法全排列：
time_t t2 = time(NULL);
Full_Array(A, n);
printf("%d\n", Count); Count = 0;
//基础回溯递归全排列：
time_t t3 = time(NULL);
Permutation(A, 0, n);
printf("%d\n", Count); Count = 0;
time_t t4 = time(NULL);
cout << "STL模版函数全排列： " << t2 - t1 << "s " << endl;
cout << "邻位对换法全排列： " << t3 - t2 << "s " << endl;
cout << "基础回溯递归全排列： " << t4 - t3 << "s " << endl;
 
 
//printf("%d\n", Count);
 
 
//递增进位制数法中序数求排位
//int *medium = get_permutation_medium_plus(A, n);
//Print(medium, n);
//int rank =get_permutation_rank_plus(medium, n);
//printf("%d\n",rank);
//int *B = get_permutation_plus(medium, n);
//Print(B, n);
 
 
//原始中序数求排位
//int *medium2 = get_permutation_medium(A, n);
//Print(medium2, n - 1);
//int *B2 = get_permutation(medium2, n - 1);
//Print(B2,n);
//int rank2 = get_permutation_rank(medium2, n);
//printf("%d\n", rank2);
 
 
//用STL模版函数循环求排位
/*
while (next_permutation(A, n)||!Count)
{
printf("原排列：  ");
Print(A, n);
printf("中介数：  ");
int *medium = get_permutation_medium_plus(A, n);
Print(medium, n);
int rank = get_permutation_rank_plus(medium, n);
printf("新序号：  %d\n", rank);
printf("---------------\n");
Count++;
}
*/
//printf("%d\n", factorial(n)-Count-1);
 
//Permutation(A, 0, n);
//printf("%d\n", Count);
 
 
//sort(A, A+n );
//Print(A,n);
 
//prev_permutation(A, A + n);
 
/*
Print(A, n);
while (next_permutation(A,  n))
{
Count++;
Print(A,n);
}
printf("%d\n", Count);
Print(A, n);
*/
system("pause");
return 0;
}