Leetcode 561. Array Partition I, Java解法

博客围绕将2n个整数分成n对,使每对中较小元素之和最大的问题展开。介绍了两种方法,方法一是排序后遍历数组,时间复杂度O(nlog(n)),空间复杂度O(1);方法二使用额外数组,时间复杂度O(n),空间复杂度O(n)。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.

Example 1:

Input: [1,4,3,2]

Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).

Note:

  1. n is a positive integer, which is in the range of [1, 10000].
  2. All the integers in the array will be in the range of [-10000, 10000].

Approach #1 Mysolution

 

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

Complexity Analysis

  • Time complexity : O(nlog(n)). Sorting takes O(nlog(n))time. We iterate over the array only once.

  • Space complexity : O(1)Constant extra space is used.

Let me try to prove the algorithm...

  1. Assume in each pair ibi >= ai.
  2. Denote Sm = min(a1, b1) + min(a2, b2) + ... + min(an, bn). The biggest Sm is the answer of this problem. Given 1Sm = a1 + a2 + ... + an.
  3. Denote Sa = a1 + b1 + a2 + b2 + ... + an + bnSa is constant for a given input.
  4. Denote di = |ai - bi|. Given 1di = bi - ai. Denote Sd = d1 + d2 + ... + dn.
  5. So Sa = a1 + a1 + d1 + a2 + a2 + d2 + ... + an + an + dn = 2Sm + Sd => Sm = (Sa - Sd) / 2. To get the max Sm, given Sa is constant, we need to make Sd as small as possible.
  6. So this problem becomes finding pairs in an array that makes sum of di (distance between ai and bi) as small as possible. Apparently, sum of these distances of adjacent elements is the smallest. If that's not intuitive enough, see attached picture. Case 1 has the smallest Sd.

Approach #2 Using Extra Array

public class Solution {
    public int arrayPairSum(int[] nums) {
        int[] arr = new int[20001];
        int lim = 10000;
        for (int num: nums)
            arr[num + lim]++;
        int d = 0, sum = 0;
        for (int i = -10000; i <= 10000; i++) {
            sum += (arr[i + lim] + 1 - d) / 2 * i;
            d = (2 + arr[i + lim] - d) % 2;
        }
        return sum;
    }
} 

 While traversing the hashmap, we determine the correct number of times each element needs to be considered as discussed above. Note that the flag dd and the sumsum remains unchanged if the current element of the hashmap doesn't exist in the array.

Complexity Analysis

  • Time complexity : O(n) The whole hashmap arr of size n is traversed only once.

  • Space complexity : O(n) A hashmap arrarr of size n is used.

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值