Analysis of Correctness and Time Efficiency of HeapPermute Algorithm

The exercises in the algorithm class require analyzing the correctness of the HeapPermute algorithm, which is really strenuous, and it has taken several hours. I read the blogs of the seniors/sisters of the 11th and 12th grades. I personally think that the proof is wrong, so I compiled a version by myself (the differences are listed after the analysis of the correctness of the algorithm). Because the proof of the correctness of the algorithm is too troublesome, some steps are omitted, Wang Haihan.

0. Exercises

HeapPermute(n)
//Implement the Heap algorithm for generating permutations
//Input: a positive integer n and a global array A[1...n] (note that n is a positive integer, not a positive integer, and this question has been wrong for nearly 10 years Also drunk)
//Output: full arrangement of elements in A
if n = 1 (1)
　write A (2)
else 　　　　　　　　　(3)
　for i ← 1 to n do 　　　(4)
　　HeapPermute(n − 1) (5)
　if n is odd (6)
　　swap A[1] and A[n] (7)
　else swap A[i] and A[n] (8)

Note: The full arrangement is the arrangement order of all elements in the array (each element is different), such as A=[1,2,3], the full arrangement is [1,2,3], [1,3,2] ], [2,1,3], [2,3,1],[3,1,2], [3,2,1]. The result and order are also processed by the HeapPermute(3) algorithm to process the array A=[ 1,2,3] the output results and their order.

For the convenience of writing and reading, "HeapPermute" is abbreviated as "HP" in the following analysis.

1. Algorithm correctness analysis

Let the global array $The\; length\; of\; A$ is$n(nis\; apositiveinteger)$ . After analysis, the following conclusions to be proved can be obtained:

Let $k$ is a positive integer and$k\le n$ . After executing the algorithm HP($k$ ), output$A$ formerkkAfter the full permutation of$k$$(n-k)$ combination of bits. In particular, when$k=When\; n$ , the output isAAThe full permutation of$A.$$k$ ) before and after, whenkkWhen$k$$A$ remains unchanged; when$When\; n$ is even,$A$ 's ex-$K$ bits rotate right one bit.
It is easy to see that the execution algorithm HP($n$ ) can output global array$A=$The full permutation of$[$$1$$.$$.$$n$$]\; is\; a\; special\; case\; of\; conclusion\; ①.\; Therefore,\; it\; is\; only\; necessary\; to\; prove\; the\; conclusion\; ①.$

The following uses mathematical induction to analyze and prove the conclusion ①. Suppose the global array $A=[a_1,a_2,\cdots ,a_n]$, $n$ is a positive integer.
　　(1) When$k=1$ , execute HP($k$ ), the output$[a_1,a_2,\cdots ,a_n]$ This is$A$ No.$1$ -bit full permutation andAAAfter$A$$(n-1)$ positional combination,$A=[a_1,a_2,\cdots ,a_n]$ , remains unchanged, consistent with the conclusion;
　　(2) When$k=2$且$k\le When\; n$ , execute HP($k$ ) after, exported$[a_1,a_2,a_3,\cdots ,a_n]$ 和 $[a_2,a_1,a_3,\cdots ,a_n]$ , is$A$ Front$2$ -bit full permutation andAAAfter$A$$n-Binary$ combination,$A=[a_2,a_1,a_3,\cdots ,a_n]$ and$A$ 's ex-$The\; k$ -bit is cyclically shifted to the right by one bit, which is consistent with the conclusion;
　　(3) Suppose$k=2m-1(mis\; apositiveinteger)$ and$k<When\; n$ , execute HP($k$ ), output$A$ formerkkAfter the full permutation of$k$$(n-k)$ combination of bits, and$A$ remains constant. When$k=2m$ , the algorithm directly enters the fourth row. For$i=1,2,\cdots ,2m$ , respectively outputAAFront of$A$$(2m-1)$ Full permutation of bits andAAAfter$A$$(n-2m+1)$ combination of bits, enter line 6, due to$n$ is an even number,$A$ 's$i$ bit and$k=2m$ bit interchange. The above$i=1,2,\cdots ,2m$ for all operations, only changing the originalAAThe first k of$A$$k=2m$ bits, just outputAAFront of$A$$(2m-1)$ full arrangement of elements andAAAfter$A$$(n-2m+1)$ A combination of bits, and then in turn$A$ 's first$1,2,\cdots ,The\; 2m$ digits are swapped to the$2m$ bits. It is easy to see that AAis obtained through the above operation$A$ 's ex-kkAfter the full permutation of$k$$(n-k)$ combination of bits, and$A$ 's ex-$K$ -bit cyclically shifts one bit to the right. Consistent with the conclusion;
　　(4) Suppose$k=2m(mis\; apositiveinteger)$ and$k<When\; n$ , execute HP($k$ ), output$A$ formerkkAfter the full permutation of$k$$(n-k)$ combination of bits, and$A$ 's ex-$K$ bits are cyclically shifted one bit to the right. Similar to (3), it can be proved that when$k=2m+1$ , the algorithm HP($The\; execution\; result\; of\; k$ ) is consistent with the conclusion.
　　Therefore, the conclusion is proved.

Note: point of divergence

I personally think that the mistakes in the proofs of the previous seniors/sisters lie in the assumption that HP( $n$ ) and array A (of length$n$ ), instead of HP($k$ ) is related to the array A. here$n$ is the array AAas the title says$The\; length\; of\; A$ ,$k$ is a positive integer and$k\le n$ . If the assumed HP($n$ ) and the array$The\; relationship\; of\; A$ cannot be directly proved by mathematical induction on the original logic. The reason is that the second step of the proof is wrong. Suppose HP($n-1$ ) For array$A$ (of length$(n-1)$ ) operation satisfies the conclusion, which means that HP($n-1$ ) for pairs of length$(n-1)$ arrays are valid, while proving that HP($n$ ) for array A($The\; premise\; that\; the\; operation\; of\; n$ ) meets the needs of the conclusion is that HP($n-1$ ) pairs of length$An\; array\; of\; n$ is valid (the specific effect is described in the conclusion at the beginning of this section). Welcome to discuss~

2. Algorithm time efficiency analysis

The time efficiency analysis of the algorithm is considered separately for the two operations of output permutation and exchange.
　　(1) Only consider the time-consuming output permutation, since the algorithm itself outputs a length of nnarrayAA$of\; n$$The\; full\; arrangement\; of\; A$ , so the algorithm complexity$T_1(n)=n!$ ;
　　(2) Considering only the time-consuming exchange operation, the following recursive expression of algorithm complexity can be obtained:
$$T_2\left(n\right)=\{\begin{array}{ll}0,& \mathrm{i}\mathrm{f}n=1\\ n+T_2(n-1),& ifn\ge 2\end{array}$$
Derivation can get $T_2\left(n\right)=n!+O\left(n^{n-1}\right)$. Since whennnWhen$n$$n!\ge n^{n-1}$ always holds. Therefore, by
O ( f ( n ) ) + O ( g ( n ) ) = O ( max { f ( n ) , g ( n ) } ) , O(f(n)) + O(g(n)) = O(max\{ f(n), g(n)\}),O(f(n))+O(g(n))=O(max{ f(n),g ( n ) } ) ,
the algorithm complexity is$T_2(n)=O(n^{n-1})$。

3. Python code

(1) Concise version code

# -*- coding: utf-8 -*-
"""
Created on Thu Apr  9 21:27:14 2020

@author: AbaloneVH
"""

import numpy as np

def swap(x, y):
  return y, x

def HP(n, A):
  if n == 1:
    print(A)
    return A
  else:
    for i in range(n):
      A = HP(n-1, A)
      if n%2 == 1:
        A[0], A[n-1] = swap(A[0], A[n-1])
      else:
        A[i], A[n-1] = swap(A[i], A[n-1])
    return A


N = 5 # 数列长度, 可调
A = np.arange(1,N+1)
A = HP(len(A), A)

(2) Code for testing

# -*- coding: utf-8 -*-
"""
Created on Thu Apr  9 21:27:14 2020

@author: AbaloneVH
"""

import numpy as np

def swap(x, y):
  return y, x

def HP(n, A, sum1, sum2):
    # sum1: 输出排列的次数
    # sum2: 交换的次数
  if n == 1:
    print(A)
    sum1 += 1
    return A, sum1, sum2
  else:
    for i in range(n):
      A, sum1, sum2 = HP(n-1, A, sum1, sum2)
      if n%2 == 1:
        A[0], A[n-1] = swap(A[0], A[n-1])
        sum2 += 1
      else:
        A[i], A[n-1] = swap(A[i], A[n-1])
        sum2 += 1
    return A, sum1, sum2


N = 5 # 数列长度, 可调
A = np.arange(1,N+1)
A, sum1, sum2 = HP(len(A), A, 0, 0)