具有最小可能交换的相对排序

Question

问题陈述： 给定 A 和 B 有两个数组。我们需要打印 b/w i'th 元素的最小交换次数，这样两个数组都将严格递增。

如果数组已经严格递增，则打印 0。 如果数组不可能严格递增，则打印 -1。

只有第 i 个元素 A 可以与 B 的第 i 个元素交换。

元素有可能出现不止一次。

例如：
输入：

t=7
A=1 2 3 8 9 7 8
B=1 2 3 4 5 10 11

输出
2

将 7 和 8 与 10 和 11 交换。或者将 8 和 9 与 4 和 5 交换。

我的代码 Python3：

t=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))

count=0
for i in range(1,t):
    if(A[i]-A[i-1]<=0):
        if(A[i]<B[i]):
            if(B[i-1]<A[i]):
                A[i],B[i]=B[i],A[i]
                count=count+1
for i in range(1,t):
    if(B[i]-B[i-1]<=0):
        if(B[i]<A[i]):
            if(A[i-1]<B[i]):
                A[i],B[i]=B[i],A[i]
                count=count+1   
ans=False
for i in range(1,t):
    if(A[i]-A[i-1]<=0):
        ans=True
        break
    if(B[i]-B[i-1]<=0):
        ans=True
        break   
if(ans):
    print(-1)
else:
    print(count)

我的代码说明： 我正在检查第一个是否在数组 A 中它是否严格增加。如果否：则检查 B 的第 i 个元素是否大于当前元素，如果是，则它大于 A 的第 i 个元素，然后再检查 B 的第 (i-1) 个元素是否小于或不小于交换的元素A.

类似的方法将应用于B。

最后一次检查 A 和 B 在交换后严格增加。如果是打印计数，否则打印-1。

---

我的代码会失败的任何测试用例还是正确的方法？ 还有其他方法可以解决这个问题吗？

Answer 1

实际上，您的代码应该使用一些方法进行重构。 这将很容易阅读。 我推荐几个简单的方法：

checkIncrement(list, index) : boolean return true if value at index > index -1 
swap(list1,list2,index) : swap value
getWrapCount(list1,list2) : return number swap

getWrapCount 方法：伪代码

    size= min_size(list1,list2);
    swapCount=0    
    for index: 1-> size
            if !checkIncrement(list1,index) or !checkIncrement(list2,index)
                swap(list1,list2,index);
                if !checkIncrement(list1,index) or !checkIncrement(list2,index) return -1;//not possible to become strictly increasing then  -1.
                swapCount++;
return (swapCount,size-swapCount);

最坏情况下复杂度为 O(N)，最好情况下复杂度为 O(1)。

Answer 2

您的代码将失败

A = [4, 2, 3]
B = [1, 5, 6]

当正确的最小交换次数为 1 时返回 2。

我们可以形成一个重复的f(i, swap) 来表示可以达到索引i 的最小交换次数，其中swap 是一个布尔值，表示是否要交换索引i 处的元素：

f(i, false) = min(
  f(i - 1, false) if A[i] > A[i-1] and B[i] > B[i-1] else Infinity,

  f(i - 1, true) if A[i] > B[i-1] and B[i] > A[i-1] else Infinity
)

f(i, true) = min(
  1 + f(i - 1, false) if B[i] > A[i-1] and A[i] > B[i-1] else Infinity,

  1 + f(i - 1, true) if B[i] > B[i-1] and A[i] > A[i-1] else Infinity
)

（时间复杂度O(n).）