最小化由N个数组成的N^2对的平方和

问题描述：

给定一个长度为N的数组A，定义一个数对为(i,j)，其中0<=i<j<N。平方和为所有数对(i,j)对应的差值的平方之和，即：

$$(A[i]-A[j])^2$$

现在要求通过重新排列A中的数字，使得平方和最小。

解决方案：

这是一个经典的问题，通常被称为最小平方和问题。一个基础的结论是，最小平方和对应着对A进行从小到大排序之后的平方和。

证明如下：

假设对A进行排序得到序列B。那么对于任意的i<j<k，有$$(B[i]-B[k])^2<= (A[i]-A[k])^2$$

因为B[i]<=B[j]<=B[k]，所以有

$$B[k]-B[i]>=A[k]-A[i]$$

所以有

$$(A[k]-A[i])^2<= (B[k]-B[i])^2$$

于是，对于任意的i<j，

$$(A[i]-A[j])^2<= (B[i]-B[j])^2$$

因此，对于任意的排列，它们的平方和不会小于排序后的平方和。

那么如何求出排序后的平方和呢？显然，排序是可以通过快速排序等常用算法实现的。时间复杂度为O(NlogN)。

下面给出Python代码实现：

def min_square_sum(A: List[int]) -> int:
    A.sort()
    N = len(A)
    s = 0
    for i in range(N-1):
        for j in range(i+1, N):
            s += (A[i] - A[j]) ** 2
    return s

这个算法的时间复杂度为O(N^2)。在N较小时表现良好，但对于较大的输入规模需要使用更优秀的算法。

接下来介绍一种时间复杂度为O(NlogN)的算法。

首先，我们将目光聚焦到一个数对(i,j)，如何计算它对平方和的贡献呢？

$$(A[i]-A[j])^2=A[i]^2-2A[i]A[j]+A[j]^2$$

注意到A已经排好序，那么以j为参照物，A[j]是固定的，A[i]是单调递增的。因此，A[i]^2和A[i]A[j]分别是单调递增的，A[j]^2是常数。根据单调性可以使用类似归并排序的算法来进行“分治”。

具体来讲，我们把问题分成两部分：在左半边数组排序后，右半边数组排序后，以及左边数组中的元素和右边数组中的元素结合组成数对的三类。

对于左右两边排序后的数对，根据前面的结论可以O(N)时间内计算它们对平方和的贡献。对于第三类，因为左半边数组和右半边数组分别已经有序，我们可以使用双指针法在O(N)时间内完成计算。

下面给出Python代码实现：

def min_square_sum(A: List[int]) -> int:
    def merge_sort(l: int, r: int) -> int:
        if l + 1 == r:
            return 0
        mid = (l + r) // 2
        sl = merge_sort(l, mid)
        sr = merge_sort(mid, r)
        s = sl + sr
        i, j = l, mid
        buf = []
        while i < mid and j < r:
            if A[i] <= A[j]:
                buf.append(A[i])
                i += 1
            else:
                buf.append(A[j])
                j += 1
                s += (mid - i)
        buf.extend(A[i:mid])
        buf.extend(A[j:r])
        A[l:r] = buf
        return s

    merge_sort(0, len(A))
    return sum((A[i] - A[j]) ** 2 for i in range(len(A)-1) for j in range(i+1, len(A)))

这个算法的时间复杂度为O(NlogN)。因为需要使用O(N)的辅助空间来进行归并排序，所以空间复杂度也是O(N)。

总结：

本文讲解了如何最小化由N个数组成的N^2对的平方和。通过排序或分治可以获得O(NlogN)的时间复杂度，使用类似归并排序的算法可以轻松实现。