LC 1877. 数组中最大数对和的最小值

题目描述

这是 LeetCode 上的 1877. 数组中最大数对和的最小值 ，难度为 中等。

一个数对 (a,b) 的数对和等于 a + b。

最大数对和是一个数对数组中最大的数对和。

比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8。

给你一个长度为偶数 n 的数组 nums，请你将 nums 中的元素分成 n / 2 个数对，使得：

• nums 中每个元素恰好在一个数对中
• 且最大数对和的值最小

请你在最优数对划分的方案下，返回最小的最大数对和。

示例 1：

输入：nums = [3,5,2,3]

输出：7

解释：数组中的元素可以分为数对 (3,3) 和 (5,2) 。
最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。

示例 2：

输入：nums = [3,5,4,2,4,6]

输出：8

解释：数组中的元素可以分为数对 (3,5)，(4,4) 和 (6,2) 。
最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。

提示：

• $n = nums.length$
• $2 <= n <= 10^5$
• n 是偶数
• $1 <= nums[i] <= 10^5$

---

基本分析 & 证明

直觉上，我们会认为「尽量让“较小数”和“较大数”组成数对，可以有效避免出现“较大数成对”的现象」。

我们来证明一下该猜想是否成立。

假定 nums 本身有序，由于我们要将 nums 拆分成 n / 2 个数对，根据猜想，我们得到的数对序列为：

$$(nums[0], nums[n - 1]), (nums[1], nums[n - 2]), ... , (nums[(n / 2) - 1], nums[n / 2])$$

换句话说，构成答案的数对必然是较小数取自有序序列的左边，较大数取自有序序列的右边，且与数组中心对称。

假设最大数对是 $(nums[i], nums[j])$，其中 $i < j$，记两者之和为 $ans = nums[i] + nums[j]$。

反证法证明，不存在别的数对组合会比 $(nums[i], nums[j])$ 更优：

假设存在数对 $(nums[p], nums[q])$ 与 $(nums[i], nums[j])$ 进行调整使答案更优。

接下来分情况讨论：

• 调整为 $(nums[i], nums[p])$ 和 $(nums[q], nums[j])$：此时最大数对答案为 $nums[q] + nums[j]$，显然 $nums[q] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和，因此该调整方案不会让答案更好；
• 调整为 $(nums[i], nums[q])$ 和 $(nums[p], nums[j])$：此时最大数对答案为 $\max(nums[i] + nums[q], nums[p] + nums[j]) = nums[p] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和，因此该调整方案不会让答案更好；

上述分析可以归纳推理到每一个“非对称”的数对配对中。

至此我们得证，将原本对称的数对调整为不对称的数对，不会使得答案更优，即贪心解可取得最优解。

---

贪心

对原数组 nums 进行排序，然后从一头一尾开始往中间组「数对」，取所有数对中的最大值即是答案。

Java 代码：

class Solution {
    public int minPairSum(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        int ans = nums[0] + nums[n - 1];
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            ans = Math.max(ans, nums[i] + nums[j]);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int minPairSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        int ans = nums[0] + nums[n - 1];
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            ans = max(ans, nums[i] + nums[j]);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def minPairSum(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        ans = nums[0] + nums[n - 1]
        i, j = 0, n - 1
        while i < j:
            ans = max(ans, nums[i] + nums[j])
            i, j = i + 1, j - 1
        return ans

TypeScript 代码：

function minPairSum(nums: number[]): number {
    nums.sort((a, b) => a - b);
    let n = nums.length;
    let ans = nums[0] + nums[n - 1];
    for (let i = 0, j = n - 1; i < j; i++, j--) {
        ans = Math.max(ans, nums[i] + nums[j]);
    }
    return ans;
};

• 时间复杂度：$O(n\log{n})$
• 空间复杂度：$O(\log{n})$

---

答疑

关于「证明」部分，不少小伙伴有一些疑问，觉得挺有代表性的，特意加到题解内。

Q1. 「证明」部分是不是缺少了“非对称”得最优的情况？

A1. 并没有，证明的基本思路如下：

1. 猜想对称组数对的方式，会得到最优解；

2. 证明非对称数组不会被对称数对方式更优。

然后我们证明了“非对称方式”不会比“对称方式”更优，因此“对称方式”可以取得最优解。

至于非对称和非对称之间怎么调整，会更优还是更差，我不关心，也不需要证明，因为已经证明了非对称不会比对称更优。

Q2. 证明部分的图 p、q 是在 i、j 内部，那么其他 p、q、i、j 大小关系的情况呢？

A2. 有这个疑问，说明没有重点理解「证明」中的加粗部分（原话）：

上述分析可以归纳推理到每一个“非对称”的数对配对中。

也就是说，上述的分析是可以推广到每一步都成立的，包括第一步，当 i 为排序数组的第一位原始，j 为排序数组中最后一位时，任意 p 和 q 都是在 i、j 内部的。

因此，「证明」对边界情况成立，同时对任意不成“对称”关系的数对也成立（其实也就是「证明」部分中的原话）。

更大白话一点是：对于任意“非对称”的数对组合，将其调整为“对称”数对组合，结果不会变差。

---

最后

这是我们「刷穿 LeetCode」系列文章的第 No.1877 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。