Arrays 相对排序两个数组的最小交换数

给定两个数组

arr1

和

arr2

，我们必须找到最小交换，以便将这两个数组相对地排序为严格递增的顺序。如果不可能进行相对排序，则返回-1

相对排序定义为交换

arr1

和

arr2

的相同索引元素

即，相对排序的步骤：

swap(arr1[i], arr2[i])

严格递增顺序定义为：

arr[i+1]>arr[i] for all i

例如：

arr1={1,4,4,9} 
arr2={2,3,5,10}

那么最小交换是1，因为交换

arr1[2]

和

arr2[2]

将使两个数组严格增加。 我用递归解决了这个问题。 如果

arr[i]>arr[i+1]

，我们可以交换索引

i

处的元素或索引

i+1

处的元素，然后调用索引

i+1

的函数。我试图找到这两个值中的最小值并返回它。

i

的每个索引都遵循此过程

int f(int N, int *arr1, int *arr2, int i){
    if(i == N-1)
        return 0;
     if(arr1[i]>=arr1[i+1] && arr2[i]>=arr2[i+1])return -1;
    if(arr1[i]>=arr1[i+1] || arr2[i]>=arr2[i+1]){
        int m, n;
        swap(arr1[i], arr2[i]);
        m = f(N, arr1, arr2, i+1);
        swap(arr1[i], arr2[i]);
        swap(arr1[i+1, arr2[i+1]);
        n = f(N, arr1, arr2, i+1);
        if(m == -1 && n==-1)return -1;
        if(m==-1)return n;
        if(n==-1)return m;
        return min(m, n);
    }
    return f(N, arr1, arr2, i+1);
 }

int minSwaps(int N, int *arr1, int *arr2){
    return f(N, arr1, arr2, 0);
}

由于这是我在一次在线编码测试中遇到的一个问题，我通过了基本测试用例，但我仍然不确定这种方法是否适用于所有测试用例

---

另外，我想知道这个问题是否可以用动态规划来解决。如果是，表中应该存储什么状态？那么应该采用什么方法呢？

您的解决方案是阵列大小的指数级。正如您在问题中所注意到的，可以使用动态规划获得解决方案

首先，让我们定义一个helper函数，该函数检查在交换

i-th和/或i+1-st

元素之后是否获得了本地有效的解决方案。我所说的局部有效的意思是只考虑这四个数字

def isValid(i, preSwap, postSwap):
  val lx = if (preSwap) y(i) else x(i)
  val rx = if (postSwap) y(i + 1) else x(i + 1)
  val ly = if (preSwap) x(i) else y(i)
  val ry = if (postSwap) x(i + 1) else y(i + 1)
  // x(i) < x(i + 1) && y(i) < y(i + 1)
  lx < rx && ly < ry

int-minSwap（向量&a、向量&b）{
int inf=（int）（1e9）；
int n=a.size（）；
int dp[n][2]；
dp[0][0]=0；
dp[0][1]=1；
对于（int i=1；iIs类似于您在帖子中询问的内容或否？@LAD不，不是。我正在编辑问题以包括一个示例如果不可能进行相对排序，那么我们必须返回-1@LAD是的，OP需要更多的关注。即使atmost 2重复整数，也可能存在不可能的状态。比如
[1,5,9]
和
[2,3,3]
。我还觉得，假设只提供有效的输入，那么这个问题就不会像看上去那么棘手了。@Nisha，这是有道理的。你可能想在帖子中说明这一点。嘿，谢谢你的回答。虽然我理解大部分内容，但我有点困惑，因为我不熟悉编写太复杂的伪代码。不是吗还有这里的PreSwap阵列？
state = (0, 1)
for i in x.length - 2 downto 0
  noPreSwap, withPreSwap = [#INFINITY], [#INFINITY]

  if (isValid(i, preSwap = false, postSwap = false)) noPreSwap += state.left
  if (isValid(i, preSwap = false, postSwap = true)) noPreSwap += state.right
  if (isValid(i, preSwap = true, postSwap = true)) withPreSwap += state.right + 1
  if (isValid(i, preSwap = true, postSwap = false)) withPreSwap += state.right

  state = (noPreSwap.min(), withPreSwap.min())
return if state.min().isInfinity() -1 else state.min()

int minSwap(vector<int>& a, vector<int>& b){
    int inf = (int)(1e9);
    int n=a.size();
    int dp[n][2];
    dp[0][0]=0;
    dp[0][1]=1;
    for(int i=1;i<n;i++)
        dp[i][0]=dp[i][1]=inf;
    for(int i=1;i<n;i++){
        if(a[i-1]<a[i]&&b[i-1]<b[i]){
            dp[i][0]=dp[i-1][0];
            dp[i][1]=dp[i-1][1]+1;
        }
        if(a[i-1]<b[i]&&b[i-1]<a[i]){
            dp[i][0]=min(dp[i][0],dp[i-1][1]);
            dp[i][1]=min(dp[i][1],dp[i-1][0]+1);
        }
    }
    return min(dp[n-1][0],dp[n-1][1]);
}