找到两个数组之间的最小可能差异

Question

我正在努力寻找一种有效的算法来执行以下任务：

给定两个长度相等的数组A和B，两个数组的差定义为：

diff = |a[0]-b[0]| + |a[1]-b[1]| +...+|a[a.length-1]-b[b.length-1]|

我需要找出 A 和 B 之间可能存在的最小差异，并且我最多可以用 A 中的任何其他元素替换 A 中的一个元素。请注意，您不需要执行替换。

例如：

A = [1,3,5]
B = [5,3,1]

如果我们把A[2]换成A[0]，那么这两个数组的区别是：

|1-5| + |3-3| + |1-1| = 4

这是两个数组之间可能的最小差异。用 A 中的另一个元素替换 A 中的一个元素不会导致 A 和 B 之间的差异更小。

我将如何解决这个问题？我知道如何解决 O(n^2) 中的问题（蛮力），但很难找到更有效的方法。

谢谢！

Answer 1

我将实施 Shridhar 的建议，即在 O(n log n) 时间内分别确定每个元素的最佳修改并采用最佳修改。

import bisect


def abs_diff(x, y):
    return abs(x - y)


def find_nearest(sorted_a, y):
    i = bisect.bisect(sorted_a, y)
    return min(
        sorted_a[max(i - 1, 0) : min(i + 1, len(sorted_a))],
        key=lambda z: abs_diff(z, y),
    )


def improvement(x, y, z):
    return abs_diff(x, y) - abs_diff(z, y)


def min_diff(a, b):
    sorted_a = sorted(a)
    nearest = [find_nearest(sorted_a, y) for y in b]
    return sum(map(abs_diff, a, b)) - max(map(improvement, a, b, nearest))


print(min_diff([1, 3, 5], [5, 3, 1]))

Answer 2

这篇文章错误地回答了这个问题的一个变体，即允许 A 中两个元素的单个 交换。我想我会留下它，因为我正在研究它。

以下是改进的一般可能性。我们可以看到，当我们交换的对具有相反的顺序时（例如，如果 a1 < b1 则 a2 > b2 ，反之亦然），就会发生改进。仔细观察，我们发现下一个质量是最佳候选交换与第一对的重叠最大。

我们可以有一个O(n log n) 例程，首先按它们的低位元素对所有给定的对进行排序，然后按低位元素的降序处理它们。当我们下降时，为a < b 的对保留一个顺序统计树，为b ≤ a 的对保留另一个。按每对的较高元素对树进行排序并保留两个装饰：（1）在左子树中看到的最大间隔，以及（2）在左子树中看到的最低低元素。

对于每个处理过的元素，选择（1）对面树中高元素相等或更低的对和最大间隔（对应第一个树装饰）和（2）具有高于或等于高元素和最低低元素的对面树（对应于第二棵树装饰）。

（由于我们按low 的降序处理这些对，所以看到的lows 将始终等于或高于当前元素。）

(1)

Original:
     a1-----------b1
                     a2----b2
Total: -----------+----

Swapped:
     a1--------------------b2
                  b1-a2
Total: --------------------+-

Result: worse.

(2)

Original:
     a1-----------b1
                     b2----a2
Total: -----------+----

Swapped:
     a1--------------b2
                  b1-------a2
Total: --------------+-------

Result: worse.

(3)

Original:
     a1-----------b1
             a2------b2
Total: -----------+------

Swapped:
     a1--------------b2
             a2---b1
Total: --------------+---

Result: the same.

(4)

Original:
     a1-----------b1
             b2------a2
Total: -----------+------

Swapped:
     a1------b2
                  b1-a2
Total: ------+-

Result: BETTER.
Improvement: 2 * dist(b2, b1)

(5)

Original:
     a1--------------b1
           a2----b2
Total: --------------+----

Swapped:
     a1----------b2
           a2--------b1
Total: ----------+--------

Result: the same.

(6)

Original:
     a1--------------b1
           b2----a2
Total: --------------+----

Swapped:
     a1----b2
                 a2--b1
Total: ----+--

Result: BETTER.
Improvement: 2 * dist(b2, a2)

(7)

Original:
     a1--------------b1
 b2--------a2
Total: --------------+--------

Swapped:
 b2----a1
           a2--------b1
Total: ----+--------

Result: BETTER.
Improvement: 2 * dist(a1, a2)

(8)

Original:
     a1-----------b1
 b2-------------------a2
Total: -----------+-------------------

Swapped:
 b2--a1
                  b1--a2
Total: --+--

Result: BETTER.
Improvement: 2 * dist(a1, b1)