数学前提
对于一个n元集合,它的全排列数量是,可以这样推导:根据乘法原理,第1个位置有n种选择,第2个位置有(n-1)种选择.....如此,则全排列的数量是
从n元集合中选择r个元素的数量是,可以这样推导:第1个元素有n种选择,第2个元素有(n-1)种选择....第r个元素有(n-r+1)种选择,但是组合是无序的,还要除以选出来的元素本身的排列,故总数量为:
组合的生成算法:最大下标法
从n元集中给出一个r元组合生成它的下一个组合算法是:
1.求出满足的最大下标 i,即
2.令
3.从第 i+1 位开始,令
这个算法,当第一个输入的组合是时,可以生成出所有的组合,代码实现如下:
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]]]
因为生成全部的组合总是要遍历到每一种组合的情况,所以这个算法的时间复杂度时
全排列的生成算法
字典序法
字典序法就是将元素都按照字典序进行排列,依次生成全排列,举个例子,集合的字典序排列如下图(这里只对1展开了)
对于一个给定的排列,生成它的下一个排列的算法是:
1.求满足关系式的 j 的最大值,记为 i 即
2.求满足关系式的 k 的最大值,记为 j 即
3.互换和
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]
这个算法的时间复杂度是,而且是就地修改序列,不额外占用空间
换位法
换位法,即算法。换位法将存储一个状态数组,这个状态有两种,-1 和 1 ,分别表示当前元素指向前一个元素或者后一个元素。每个元素的初始状态都将被设置为 -1 。一个元素是活动的,当且仅当该元素状态指向的元素小于该元素。当所有的元素都不处于活动状态时,生成排列完毕。
举个例子,如下图
给定一个排列,生成下一个排列的方法是:
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]
这个算法的时间复杂度是。根据输出结果注意到,这个算法其实是让最大的元素在序列中从后向前,再从前向后,也是就地修改序列,只额外占用存储状态数组的空间
回顾往期: