Python 对数组进行冒泡排序所需的最小交换次数是多少？

我正试图解决黑客银行的问题：

进一步的解释可以在页面上找到。例如，将“交换”队列表示为

q

，如果

q=[2,1,5,3,4]

，则所需的交换数量为3：

根据的第一个答案，冒泡排序所需的交换数等于数组中的反转数。我试图用以下Hackerrank提交的内容来测试这一点：

#!/bin/python

import sys


T = int(raw_input().strip())
for a0 in xrange(T):
    n = int(raw_input().strip())
    q = map(int,raw_input().strip().split(' '))
    # your code goes here
    diff = [x - y for x, y in zip(q, range(1,n+1))]
    if any([abs(el) > 2 for el in diff]):
        print "Too chaotic"
    else:
        all_pairs = [(q[i], q[j]) for i in range(n) for j in range(i+1, n)]
        inversions = [pair[0] > pair[1] for pair in all_pairs]
        print inversions.count(True)

以下是要在本地运行的代码版本：

n = 5
q = [2, 1, 5, 3, 4]

diff = [x - y for x, y in zip(q, range(1,n+1))]
if any([abs(el) > 2 for el in diff]):
    print "Too chaotic"
else:
    all_pairs = [(q[i], q[j]) for i in range(n) for j in range(i+1, n)]
    inversion_or_not = [pair[0] > pair[1] for pair in all_pairs]
    print inversion_or_not.count(True)

对于给定的测试用例，脚本正确地打印数字3。但是，对于所有其他“隐藏”测试用例，它给出了错误的答案：

我还尝试了一个实现气泡排序的提交：

#!/bin/python

import sys

def swaps_bubble_sort(q):
    q = list(q)         # Make a shallow copy
    swaps = 0
    swapped = True
    while swapped:
        swapped = False
        for i in range(n-1):
            if q[i] > q[i+1]:
                q[i], q[i+1] = q[i+1], q[i]
                swaps += 1
                swapped = True
    return swaps

T = int(raw_input().strip())
for a0 in xrange(T):
    n = int(raw_input().strip())
    q = map(int,raw_input().strip().split(' '))
    # your code goes here
    diff = [x - y for x, y in zip(q, range(1,n+1))]
    if any([abs(el) > 2 for el in diff]):
        print "Too chaotic"
    else:
        print swaps_bubble_sort(q)

---

但结果是一样的（失败）。最小互换数量是否不等于反向互换数量或通过冒泡排序获得的互换数量？

您只需在冒泡排序中计算必要互换的数量即可。这是我被接受的代码

T = input()
for test in range(T):
    n = input()
    l = map(int, raw_input().split())
    for i,x in enumerate(l):
        if x-(i+1) > 2:
            print "Too chaotic"
            break
    else:
        counter = 0
        while 1:
            flag = True
            for i in range(len(l)-1):
                if l[i] > l[i+1]:
                    l[i],l[i+1] = l[i+1],l[i]
                    counter += 1
                    flag = False
            if flag:
                break
        print counter

在您的第一个代码中，您的方法是

O（n^2）

，这不适用于

n=10^5

。在这一行

all_pairs = [(q[i], q[j]) for i in range(n) for j in range(i+1, n)]

您正试图在RAM中存储

10^10

元组

第二个代码的问题是，您正在使用diff元素的

abs

，以确保数组不混乱。然而，一个人只有在受贿的情况下才能走到最后，这并不违反规则。因此，你只需确保一个人不会站出来超过两个位置，而不是相反方向。

Swift 4版本：

func minimumBribes（队列：[Int]）->Int？{
对于队列中的（索引，值）。枚举（）{
如果值-（index+1）>2{/`+1`是必需的，因为索引从“0”开始，而不是从“1”开始。
归零
}
}
变量计数器=0
var queue=queue//只是输入值的可变副本。
虽然是真的{
var isSorted=true
对于0中的i..队列[i+1]{
队列.swapAt（i，i+1）
计数器+=1
isSorted=false
}
}
如果被分类{
打破
}
}
返回计数器
}
//完成下面的minimumBribes功能。
func minimumBribes（q:[Int]）->Void{
如果let value=minimumBribes（队列：q）{
打印（“\（值）”）
}否则{
打印（“太乱”）
}
}

清洁python解决方案：

def minimumBribes(q):
    b = 0
    for i, x in enumerate(q):
        if x - i > 3:
            print('Too chaotic')
            return
        for y in q[max(0, x - 2):i]:
            if y > x:
                b += 1
    print(b)

---

请不要将文本作为图像发布。请尝试生成您自己的测试用例。