1 逆序

  逆序的概念大家都不陌生，它在行列式理论中是很重要的。

  设$i_1,i_2,\cdots ,i_n$是集合 { 1 , 2 , ⋯   , n } \{1,2,\cdots,n\} { 1,2,⋯,n}的一个排列。如果$k<l$且$i_k>i_l$，则称数对$(i_k,i_l)$为一个逆序。通俗地讲，一个排列中的逆序对应着不以自然顺序出现的一对数。例如$31524$中的逆序有$(3,1),(3,1),(5,2),(5,4)$。显然集合 { 1 , 2 , ⋯   , n } \{1,2,\cdots,n\} { 1,2,⋯,n}的自然顺序$12\cdots n$是唯一没有逆序的排列。

  对于一个排列$i_1,i_2,\cdots ,i_n$，令$a_j$表示逆序对第二个成分为$j$的逆序对数量，即$a_j$表示在排列中在$j$前面且大于$j$的整数的个数。它度量$j$的无序程度。

  逆序列：数值序列$a_1,a_2,\cdots ,a_n$叫做排列$i_1,i_2,\cdots ,i_n$逆序列。$a_1+a_2+\cdots +a_n$度量一个排列的无序程度。例如$31524$的逆序列为$1,2,0,1,0$。

  逆序列满足下面的条件：
$$\begin{gathered} 0\le a_1\le n-1 \\ 0\le a_2\le n-2 \\ \cdots \\ 0\le a_{n-1}\le 1 \\ {a}_n=0 \end{gathered}$$
这个条件的原因很显然，对于每个$k=1,2,\cdots ,n$，在集合中存在$n-k$个大于$k$的整数。显然满足上述条件的序列个数等于$n\ast (n-1)\ast \cdots 1=n!$。这个数等于 { 1 , 2 , ⋯   , n } \{1,2,\cdots,n\} { 1,2,⋯,n}的排列个数。

2 定理

  设$b_1,b_2,\cdots ,b_n$是满足下面条件的整数序列：
$$\begin{gathered} 0\le b_1\le n-1 \\ 0\le b_2\le n-2 \\ \cdots \\ 0\le b_{n-1}\le 1 \\ {b}_n=0 \end{gathered}$$
那么，一定存在一个唯一一个 { 1 , 2 , ⋯   , n } \{1,2,\cdots,n\} { 1,2,⋯,n}排列，它的逆序列是$b_1,b_2,\cdots ,b_n$。我们可以通过找到唯一构建逆序列的排列的方法来证明这个定理。

算法1：从逆序构建一个排列

  算法步骤如下：

• $n$：写出$n$。
• $n-1$：考虑$b_{n-1}$。我们知道$0\le b_{n-1}\le 1$。如果$b_{n-1}=0$，则$n-1$应该放在$n$的前面。如果$b_{n-1}=1$，则$n-1$应该放在$n$的后面。
• $n-2$：考虑$b_{n-2}$。类似地，我们知道$0\le b_{n-1}\le 2$。如果$b_{n-2}=0$，则$n-2$应该放在上一步构建完的两个数的前面。如果$b_{n-2}=1$，则$n-2$应该放在两个数的中间。如果$b_{n-2}=0$，则$n-2$应该放在两个数的后面。
• $\cdots \cdots$
• $n-k$：（一般步骤）我们知道$0\le b_{n-k}\le k$，从步骤$n$到步骤$n-k+1$中，$k$个数$n,n-1,\cdots ,n-k+1$的顺序都已经排好了。如果$b_{n-k}=0$则放在最前面$\dots \dots$如果$b_{n-k}=k$则放在最后面。
• $\cdots \cdots$
• $1$：我们必须把$1$放在上一步所构造的序列的第$b_1$个数的后面。

  通过上述步骤构建排列时，步骤$n,n-1,n-2,\cdots ,1$根据逆序列$b_1,b_2,\cdots ,b_n$唯一确定 { 1 , 2 , ⋯   , n } \{1,2,\cdots,n\} { 1,2,⋯,n}的一个排列。这个算法的缺点是：排列中的每一个整数的位置不到最后是不得而知的，算法在执行的过程中只做到了这些整数的相对位置保持固定。

  例子：构建 { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } \{1,2,3,4,5,6,7,8\} { 1,2,3,4,5,6,7,8}的一个排列，使其逆序列是$5,3,4,0,2,1,1,0$。根据上述算法：
$$\begin{array}{rl}& 8:8\\ & 7:87\\ & 6:867\\ & 5:8657\\ & 4:48657\\ & 3:486537\\ & 2:4862537\\ & 1:48625137\end{array}$$

python实现起来也比较容易：

def generate_algo1(seq): permutation = [] for i in range(len(seq), 0, -1): permutation.insert(int(seq[i-1]), i) return permutation seq = input().split() print(generate_algo1(seq)) 

输入：5 3 4 0 2 1 1 0 输出：[4, 8, 6, 2, 5, 1, 3, 7] 

算法2：从逆序列构建一个排列

  我们从$n$个空位置上出发，把这些空位置从左到右标记上$1,2,\cdots ,n$。算法步骤如下：

• $1$：因为在这个排列中$1$之前有$b_1$个整数，所以必须把$1$放在位置标签为$b_1+1$的位置上。
• $2$：因为在这个排列中有$b_2$个整数大于$2$且在$2$之前，又因为这些证书还没有被插入进来，所以必须给这些数留出$b_2$个空位置。因此，把$2$放在第$b_2+1$的空位置上。
• $\cdots \cdots$
• $k$：（一般步骤）因为在这个排列中$k$前面还应该有$b_k$个整数，这些整数还没有被插进来，因此必须给这些数留出$b_k$个空位置。在本步骤开始时，空位置的个数是$n-(k-1)=n-k+1$，把$k$放在从左边数第$b_k+1$个空位置上。因为$b_k\le n-k$，所以可以确定一个空位置。
• $\cdots \cdots$
• $n$：把$n$放在剩下的一个空位置上。

  这种方法中，$1,2,\cdots ,n$在排列中的位置是确定的。依旧用上述例子$5,3,4,0,2,1,1,0$来过一遍该算法：
$$\begin{array}{rl}& 1:\_\_\_\_\_1\_\_\\ & 2:\_\_\_2\_1\_\_\\ & 3:\_\_\_2\_13\_\\ & 4:4\_\_2\_13\_\\ & 5:4\_\_2513\_\\ & 6:4\_62513\_\\ & 7:4\_625137\\ & 8:48625137\end{array}$$
python实现：

def generate_algo2(seq): n = len(seq) permutation = [None]*n for i in range(1, n+1): j, k = 0, int(seq[i-1]) + 1 while j < n: if not permutation[j]: k -= 1 if k == 0: permutation[j] = i break j += 1 return permutation 

输入：5 3 4 0 2 1 1 0 输出：[4, 8, 6, 2, 5, 1, 3, 7] 

3 奇排列与偶排列

  习惯上，按照某个排列中的逆序个数是偶数还是奇数而把 { 1 , 2 , ⋯   , n } \{1,2,\cdots, n\} { 1,2,⋯,n}的这个排列$i_1{i}_2\cdots i_n$称为偶排列或奇排列。排列的符号按照排列是偶排列还是奇排列而定义为$+1,-1$。行列式的定义就包含了这一点，$n\ast n$的矩阵$A=[a_{ij}](i=1,2,\cdots ,n)$，其行列式为
$$det(A)=\sum \epsilon (i_1{i}_2\cdots i_n)a_{1i_1}{a}_{2i_2}\cdots a_{n{i}_n}$$
其中$\epsilon (i_1{i}_2\cdots i_n)$为$i_1{i}_2\cdots i_n$的符号。

4 交换得到自然顺序

  如果排列$i_1{i}_2\cdots i_n$有逆序列$b_1,b_2,\cdots ,b_n$且$k=b_1+b_2+\cdots +b_n$为逆序数，那么可以通过连续$k$次交换相邻两个数而把$i_1{i}_2\cdots i_n$转化成$12\cdots n$。步骤为：

• 首先连续地把$1$与它左边的$b_1$个整数交换；
• 再连续地把$2$与它左边大于$2$的整数交换；
• $\cdots$

  例子：交换$361245$到$123456$。
$$\begin{gathered} 361245 \\ 316245 \\ 136245 \\ 132645 \\ 123645 \\ 123465 \\ 123456 \end{gathered}$$

5 参考资料

• 《组合数学》第五版 P57-P60