如何在 k 次交换中从 2 个 arrays 获得最小加法结果？

Question

我遇到了一个有趣的算法（也许是：/）问题，因为我刚刚开始使用算法和数据结构，所以我有点难以解决。 你能看看，也许给我一些建议：）

这里有两个问题：有两个 integer arrays 长度相同 - n，一个开关编号 k最多允许在2 个 arrays 之间交换 k 次，如何找到 k 交换后的最小加法结果？

重要的是：

在 2 次交换之间，元素应该来自同一个数组！

这可能有点令人困惑............这里是一个例子：

ex:           
     {1, 5, 3, 2, 4}  Array A          
     {3, 4, 1, 6, 2}  Array B       
     k - 2            Max swap chance 
     the minimum result should be 1-A[0] + 4-B[1] + 1-B[2] + 2-A[3] + 4-A[4] = 12
                                      first swap         second swap
                                       A -> B               B -> A
There is path like :
                      1        2   4
                         4  1

请注意：

如果我们选择 A[0]（因为 A[0] < B[0] ），那么数组 A 必须是基本数组。

And the swap here:  1 A[1] ->  4 B[1]  is the first swap 
                    after above swap, the next number have to be 1 (B[2]) if we do not do another swap from B to A
                    1 A[3] ->  2 B[3] is the second swap

在我的例子中：

我们在数组 A 中选择 1，然后第一次交换（ replace ）发生在 A[1] 和 B[1] 之间，第二次交换发生在 A[3] 之后，我们现在无法进行更多交换，因为 k 已经达到 2 (k 应该 <= 2)

在以下情况下：

          {1 5 3 7 1 1 3}
          {3 1 4 1 3 9 2}
             ^       ^
 if we only have at most 2 chance to swap, they should happen at '^' because 
           1         1 3
             1 4 1 3       
 could result in minimum addition result   

让它更通用：

     {1, 5, ... , 3, ... , 2, 4}  Array A          
     {3, 4, ... , 1, ... , 6, 2}  Array B       
     k - n            Max swap chance 
     The key point here is: how could I decide whether the first swap should still
happen between A[1] and B[1] or there may be another better chance to do a swap
between A[i-th] and B[i-th] .
     And we only have at most k times swap chance, so when and where should the
k swaps happen need to be considered carefully..

我试图让问题更清楚，如果还有什么令人困惑的地方，请告诉我。 关于如何决定在哪里交换以及交换多少次并最终获得最小计算结果的任何想法？ 非常感谢！

Answer 1

好吧，如果我对您的理解正确，您有2可能性：

1. 交换每对第i个项目的项目以使A数组包含最少项目
2. 交换每对第i个项目的项目以使B数组包含最少项目

在你的情况下：

让我们让A有最少的项目：

 {1, 5, 3, 2, 2}  Array A          
 {3, 4, 1, 6, 4}  Array B     
 ---------------
 {1  4  1  2  2}  Min (based on A, 2 swaps)
     ^  ^
     swap (we take items from B)

让我们让B有最少的项目：

 {1, 5, 3, 2, 2}  Array A          
 {3, 4, 1, 6, 4}  Array B     
 ---------------
 {1  4  1  2  2}  Min (based on B, 3 swaps)
  ^        ^  ^
     swap (we take items from A)     

这里2 < 3所以我们应该让A包含最少的项目，我们可以在2交换中完成

到目前为止，一般情况下你可以

1. 计算使A包含每对的最少项目所需的交换（让它成为swapsA ）。
2. 计算使B包含每对的最少项目所需的交换次数（让它成为swapsB ）。
3. 返回Min(swapsA, swapsB)

可能的 C#代码

int[] A = ...
int[] B = ...

int swapsA = 0;
int swapsB = 0;

int sum = 0;

for (int i = 0; i < A.Length; ++i) {  
  sum += Math.Min(A[i], B[i]); 

  if (A[i] > B[i]) 
    swapsA += 1; 
  else if (A[i] < B[i]) 
    swapsB += 1;
}

int swaps = Math.Min(swapsA, swapsB);

Console.Write($"We have to make at least {swaps} swaps; the min sum is {sum}");

编辑：唯一的困难是当项目相等时，例如

 {1, 5, 1, 2, 4}  Array A  # note that 3d and 4th pairs have equal items        
 {3, 4, 1, 2, 2}  Array B     
 ---------------
 {1  4  1  2  2}  Min (based on A, 1 swap)
     ^        ^
     swap (we take items from B)

让我们让B有最少的项目：

 {1, 5, 1, 2, 4}  Array A          
 {3, 4, 1, 2, 2}  Array B     
 ---------------
 {1  4  1  2  4}  Min (based on B, 2 swaps)
  ^           
     swap (we take items from A)     

请注意，在一般情况下swapsA + swapsB <= A.Length

编辑 2：如果您有多达K次交换要执行，您可以订购它们并取K最有希望的（最大A[i] - B[i]差异）：

让我们交换和求和A

      {1 5 3 7 1 1 3} A 
      {3 1 4 1 3 9 2} B
         ^   ^     ^
         reasonable swaps - 3 - more than allowed 2

      {5, 1} drops sum by 5 - 1 == 4 # most promising (a best sum drop)
      {7, 1} drops sum by 7 - 1 == 6 # most promising (a best sum drop)
      {3, 2} drops sum by 3 - 2 == 1

最有希望的交换是{7, 1}和{5, 1} 。 所以我们有1 + 1 + 3 + 1 + 1 + 1 + 3 。

让我们交换和求和A

      {1 5 3 7 1 1 3} A 
      {3 1 4 1 3 9 2} B
       ^   ^   ^ ^ 
       reasonable swaps - 4 - more than allowed 2

      {1, 3} drops sum by 3 - 1 == 2 # most promising (a best sum drop)
      {3, 4} drops sum by 4 - 3 == 1
      {1, 3} drops sum by 3 - 1 == 2  
      {1, 9} drops sum by 9 - 1 == 8 # most promising (a best sum drop)

所以我们有{1, 3}和{1, 9}交换更有希望，总和是1 + 1 + 4 + 1 + 3 + 1 + 2 。

最后，您应该比较两种可能性（如果您从A或B做出最小总和）