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:
- n is a positive integer, which is in the range of [1, 10000].
- 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...
- Assume in each pair
i
,bi >= ai
. - Denote
Sm = min(a1, b1) + min(a2, b2) + ... + min(an, bn)
. The biggestSm
is the answer of this problem. Given1
,Sm = a1 + a2 + ... + an
. - Denote
Sa = a1 + b1 + a2 + b2 + ... + an + bn
.Sa
is constant for a given input. - Denote
di = |ai - bi|
. Given1
,di = bi - ai
. DenoteSd = d1 + d2 + ... + dn
. - So
Sa = a1 + a1 + d1 + a2 + a2 + d2 + ... + an + an + dn = 2Sm + Sd
=>Sm = (Sa - Sd) / 2
. To get the maxSm
, givenSa
is constant, we need to makeSd
as small as possible. - So this problem becomes finding pairs in an array that makes sum of
di
(distance betweenai
andbi
) 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 smallestSd
.
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.