Question

我正在编写一个可以生成元素列表的所有排列以及基于原始列表的排列签名的代码。

通常，排列数由第一类斯特林数给出，它由k = n-划分n个元素的C环组成。

       [n]           [n - 1]   [n - 1]
       [ ] = (n - 1) [     ] + [     ]
       [k]           [  k  ]   [k - 1]

将n个元素划分为k个周期的方法的数量是将n-1个非最大元素划分为k个周期，并以n-1种方式之一拼接最大元素，或者将最大元素置于其自身的周期中。将n-1个非最大元素划分为k-1个周期。然后，符号将由（-1）^ N-C给出，其中N是索引数，C是元素从其原始位置移动时形成的循环数。

我已经对Heap算法的一种变体进行了编码，该算法可以产生每个排列的签名。

    def permute(a, l, r): 
        if l==r:          
            print'Permutation--:',a
        else: 
            for i in xrange(l,r+1): 
                if i!=l:
                    a[0]=(-1)*int(a[0])#Sign for permutation
                a[l], a[i] = a[i], a[l] 
                permute(a, l+1, r)             
                a[l], a[i] = a[i], a[l]                         
                if i!=l:#Sign for permutation
                    a[0]=(-1)*int(a[0])




    test = "1hgfe"
    n = len(test) 
    a = list(test) 
    permute(a, 1, n-1)

在例行置换中，引入列表a，列表a的第一个成员a [0]是符号，在这种情况下为+1，对于每个排列，列表的单数乘以-1。到目前为止，我认为代码有效，这是测试的结果。

          ['1', 'h', 'g', 'f', 'e']  (h->h) (g->g) (f->f) (e->e)       (-1)^(4-4) or identity =+1  
          [-1, 'h', 'g', 'e', 'f']   (h->h) (g->g) (f->e)              (-1)^(4-3)=-1
          [-1, 'h', 'f', 'g', 'e']   (h->h) (g->f) (e->e)              (-1)^(4-3)=-1
          [1, 'h', 'f', 'e', 'g']    (h->h) (g->f->e)                  (-1)^(4-2)=+1
          [-1, 'h', 'e', 'f', 'g']   (h->h) (g->e) (f->f)              (-1)^(4-3)=-1
          [1, 'h', 'e', 'g', 'f']    (h->h) (g->e->f)                  (-1)^(4-2)=+1
          [-1, 'g', 'h', 'f', 'e']   (h->g) (f->f) (e->e)              (-1)^(4-3)=-1
          [1, 'g', 'h', 'e', 'f']    (h->g) (f->e)                     (-1)^(4-2)=+1
          [1, 'g', 'f', 'h', 'e']    (h->g->f) (e->e)                  (-1)^(4-2)=+1
          [-1, 'g', 'f', 'e', 'h']   (h->g->f->e)                      (-1)^(4-1)=-1
          [1, 'g', 'e', 'f', 'h']    (h->g->e) (f->f)                  (-1)^(4-2)=+1
          [-1, 'g', 'e', 'h', 'f']   (h->g->e->f)                      (-1)^(4-1)=-1
          [-1, 'f', 'g', 'h', 'e']   (h->f) (g->g)(e->e)               (-1)^(4-3)=-1
          [1, 'f', 'g', 'e', 'h']    (h->f->e) (g->g)                  (-1)^(4-2)=+1
          [1, 'f', 'h', 'g', 'e']    (h->f->g) (e->e)                  (-1)^(4-2)=+1
          [-1, 'f', 'h', 'e', 'g']   (h->f->e->g)                      (-1)^(4-1)=-1
          [1, 'f', 'e', 'h', 'g']    (h->f) (g->e)                     (-1)^(4-2)=+1
          [-1, 'f', 'e', 'g', 'h']   (h->f->g->e)                      (-1)^(4-1)=-1
          [-1, 'e', 'g', 'f', 'h']   (h->e) (g->g) (f->f)              (-1)^(4-3)=-1
          [1, 'e', 'g', 'h', 'f']    (h->e->f) (g->g)                  (-1)^(4-2)=+1
          [1, 'e', 'f', 'g', 'h']    (h->e) (g->f)                     (-1)^(4-2)=+1
          [-1, 'e', 'f', 'h', 'g']   (h->e->g->f)                      (-1)^(4-1)=-1
          [1, 'e', 'h', 'f', 'g']    (h->e->g) (f->f)                  (-1)^(4-2)=+1
          [-1, 'e', 'h', 'g', 'f']   (h->e->f->g)                      (-1)^(4-1)=-1

我的问题是：您认为我的代码是否适用于任何列表大小，即[1，A，B，C ......，Z_n]？有没有更有效的方法来生成排列及其符号？

Answer 1

是的，您的方法是正确的。与其直接证明这一点，不如证明

（1） permute(a, l, r)的执行返回l的第r至第a个字母的每个排列仅一次和退出，其中a等于执行开始时的值。

这很容易通过对r - l的归纳证明。如果没有声明中“ a相等的退出”部分，那就很难了。

至于正确的符号，这只是一个循环不变式：每次交换两个不同的条目时，都将符号乘以-1，这是您唯一更改符号的时间。因此，是的，第0个条目是过程中每次更改的符号。

Knuth的TAoCP（第4A卷）的第7.2.1.2节专门介绍生成所有排列的算法。它们中的一些也可以很容易地修改以产生它们的符号。我想知道你是否在其中。

具有置换签名的堆算法

1 个答案: