LC 561. 数组拆分 I

题目描述

这是 LeetCode 上的 561. 数组拆分 I ，难度为简单。

给定长度为 $2 \times n$ 的整数数组 nums，你的任务是将这些数分成 n 对, 例如 $(a_1, b_1), (a_2, b_2), …, (a_n, b_n)$ ，使得从 1 到 n 的 $\min(a_i, b_i)$ 总和最大。

返回该最大总和。

示例 1：

输入：nums = [1,4,3,2]
输出：4
解释：所有可能的分法（忽略元素顺序）为：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4

示例 2：

1
2
3

输入：nums = [6,2,6,5,1,2]
输出：9
解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

提示：

$1 <= n <= 10^4$
$nums.length = 2 \times n$
$-10^4 <= nums[i] <= 10^4$

贪心

我们先对数组进行排序。

由于每两个数，我们只能选择当前小的一个进行累加。

因此我们猜想应该从第一个位置进行选择，然后隔一步选择下一个数。这样形成的序列的求和值最大。

Java 代码：

class Solution {
    public int arrayPairSum(int[] nums) {
        int n = nums.length, ans = 0;
        Arrays.sort(nums);
        for (int i = 0; i < n; i += 2) ans += nums[i];
        return ans;
    }
}

C++ 代码：

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

Python 代码：

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        ans = 0
        for i in range(0, len(nums), 2):
            ans += nums[i]
        return ans

TypeScript 代码：

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

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

证明

解法不难，重点是要证明该做法的正确性，这才是”贪心”类算法题的意义。

我们用反证法来证明下，为什么这样选择的序列的求和值一定是最大的：

猜想：对数组进行排序，从第一个位置进行选择，然后隔一步选择下一个数。这样形成的序列的求和值最大（下图黑标，代表当前被选择的数字）。

之所以我们能这么选择，是因为每一个被选择的数的「下一位位置」都对应着一个「大于等于」当前数的值（假设位置为 k ），使得当前数在 min(a,b) 关系中能被选择（下图红标，代表保证前面一个黑标能够被选择的辅助数）。

假如我们这样选择的序列求和不是最大值，那么说明至少我们有一个值选错了，应该选择更大的数才对。

那么意味着我们「某一位置」的黑标应该从当前位置指向更后的位置。

PS. 因为要满足 min(a, b) 的数才会被累加，因此每一个红标右移（变大）必然导致原本所对应的黑标发生「同样程度或不同程度」的右移（变大）

这会导致我们所有的红标黑标同时往后平移。

最终会导致我们最后一个黑标出现在最后一位，这时候最后一位黑标不得不与我们第 k 个位置的数形成一对。

我们看看这是求和序列的变化（ k 位置前的求和项没有发生变化，我们从 k 位置开始分析）：

原答案 = nums[k] + nums[k + 2] + ... + nums[n - 1]
调整后答案 = nums[k + 1] + nums[k + 3] + ... + nums[n - 2] + min(nums[n], nums[k])
由于 min(nums[n], nums[k]) 中必然是 nums[k] 被选择。因此：
调整后答案 = nums[k] + nums[k + 1] + nums[k + 3] + ... + nums[n - 2]

显然从原答案的每一项都「大于等于」调整后答案的每一项，因此不可能在「假想序列」中通过选择别的更大的数得到更优解，假想得证。

为什么要「证明」或「理解证明」？

证明的意义在于，你知道为什么这样做是对的。

带来的好处是：

一道「贪心」题目能搞清楚证明，那么同类的「贪心」题目你就都会做了。否则就会停留在“我知道这道题可以这样贪心，别的题我不确定是否也能这样做”。
在「面试」阶段，你可以很清晰讲解你的思路。让面试官从你的「思维方式」上喜欢上你（ emmm 当然从颜值上也可以 :)
…

最后

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

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

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

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

贪心

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

LC 566. 重塑矩阵上一篇

LC 485. 最大连续 1 的个数下一篇

LC 561. 数组拆分 I

题目描述

贪心

证明

为什么要「证明」或「理解证明」？

更多与证明/分析相关的题解：

最后