全排列,组合的生成算法(python版)

数学前提

对于一个n元集合,它的全排列数量是n!,可以这样推导:根据乘法原理,第1个位置有n种选择,第2个位置有(n-1)种选择.....如此,则全排列的数量是n!

从n元集合中选择r个元素的数量是\binom{n}{r},可以这样推导:第1个元素有n种选择,第2个元素有(n-1)种选择....第r个元素有(n-r+1)种选择,但是组合是无序的,还要除以选出来的元素本身的排列,故总数量为:\frac{n(n-1)(n-2)...(n-r+1)}{r!}=\frac{n!}{(n-r)!r!}=\binom{n}{r}

组合的生成算法:最大下标法

从n元集中给出一个r元组合(a_{i,1},a_{i,2},...a_{i,r})生成它的下一个组合算法是:

1.求出满足a_i<n-r+i的最大下标 i,即i=\max{\{j|a_j<n-r+j\}}

2.令a_i = a_i+1

3.从第 i+1 位开始,令a_j = a_{j-1}+1

这个算法,当第一个输入的组合是(a_1,a_2,...a_r)时,可以生成出所有的组合,代码实现如下:

def combination(datas:list,r:int):
    length = len(datas)
    ans = []
    selectSequence = [i+1 for i in range(r)]
    while True:
        ans.append([datas[i-1] for i in selectSequence])
        maximum = -1
        for i in range(r):
            if selectSequence[i] < length-r+(i+1) and (i+1)>maximum:
                maximum = i+1
        if maximum == -1:
            break
        selectSequence[maximum-1] += 1
        for i in range(maximum,r):
            selectSequence[i] = selectSequence[i-1]+1
    return ans

测试结果如下:

datas = ["a","r",456,[1,2]]
ans = combination(datas,2)
print(ans)

>>>
[['a', 'r'], ['a', 456], ['a', [1, 2]], ['r', 456], ['r', [1, 2]], [456, [1, 2]]]

因为生成全部的组合总是要遍历到每一种组合的情况,所以这个算法的时间复杂度时O(\binom{n}{r}) 

全排列的生成算法

字典序法

字典序法就是将元素都按照字典序进行排列,依次生成全排列,举个例子,集合\{1,2,3,4\}的字典序排列如下图(这里只对1展开了)

对于一个给定的排列[a_{i,1},a_{i,2},...,a_{i,n}],生成它的下一个排列的算法是:

1.求满足关系式a_{j-1}<a_{j}的 j 的最大值,记为 i 即i = \max{\{j|a_{j-1}<a_{j}\}}

2.求满足关系式a_{i-1}<a_k的 k 的最大值,记为 j 即j=\max{\{k|a_{i-1}<a_{k}\}}

3.互换a_{i-1}a_{j}

4.将互换之后的序列的第 i-1 位之后的元素逆序,得到下一个排列

代码实现如下:

def dictArrange(n):
    elements = list(range(1,n+1))
    while True:

        # do something here
        print(elements)

        i,j = -1,-1
        for index in range(n-1):
            if elements[index] < elements[index+1] and index > i:
                i = index
        if i == -1:
            break
        for index in range(n):
            if elements[index] > elements[i] and index > j:
                j = index
        elements[i],elements[j] = elements[j],elements[i]
        left, right = i + 1, n - 1
        while left < right:
            elements[left], elements[right] = elements[right], elements[left]
            left += 1
            right -= 1

测试如下

dictArrange(3)

>>>[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

这个算法的时间复杂度是O(n!),而且是就地修改序列,不额外占用空间

换位法

换位法,即Johnson-Trotter算法。换位法将存储一个状态数组,这个状态有两种,-1 和 1 ,分别表示当前元素指向前一个元素或者后一个元素。每个元素的初始状态都将被设置为 -1 。一个元素是活动的,当且仅当该元素状态指向的元素小于该元素。当所有的元素都不处于活动状态时,生成排列完毕。

举个例子,如下图

给定一个排列[a_{i,1},a_{i,2},...a_{i,n}],生成下一个排列的方法是:

1.求出所有处于活跃状态的元素中最大的元素,记为 m 

2.将 m 和它指向的元素互换位置

3.将序列中所有大于 m 的元素指向的箭头转换方向

代码实现如下:

def arrange(n:int):
    elements = list(range(1,n+1))
    status = [-1 for _ in range(n)]
    while True:

        # do something here
        print(elements)

        maxIndex,maximum = -1,-1
        for index in range(n):
            temp_index = index + status[index]
            if 0 <= temp_index < n and elements[index] > elements[temp_index] and elements[index] > maximum:
                maxIndex = index
                maximum = elements[index]
        if maxIndex == -1:
            break
        temp_index = maxIndex + status[maxIndex]
        elements[temp_index],elements[maxIndex] = elements[maxIndex],elements[temp_index]
        status[temp_index],status[maxIndex] = status[maxIndex],status[temp_index]
        for index in range(n):
            if elements[index] > maximum:
                status[index] *= -1

 测试如下:

arrange(3)

>>>[1, 2, 3]
[1, 3, 2]
[3, 1, 2]
[3, 2, 1]
[2, 3, 1]
[2, 1, 3]

这个算法的时间复杂度是O(n!)。根据输出结果注意到,这个算法其实是让最大的元素在序列中从后向前,再从前向后,也是就地修改序列,只额外占用存储状态数组的空间

回顾往期:

基本排序方法的python实现

普利姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法C语言实现

栈,队列,二叉树的实现和基本方法

  • 4
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值