LeetCode: 561. Array Partition I

561. Array Partition I

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.

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].

大意如下：

在2n长度的数组中，两两一组，将每组中较小的数累加起来，求一个最大值。

自己的解法，重复造轮子，用的归并排序，效率是O(nlogn)。具体解释请看 归并排序

public class Solution {
    public int arrayPairSum(int[] nums) {
        int[] numsA = arrayPair(nums);
        int result = 0;
        for (int i = 0; i < numsA.length; i += 2) {
            result += numsA[i];
        }
        return result;
    }

    private int[] arrayPair(int[] nums) {
        if (nums.length == 1) {
            return nums;
        }
        if (nums.length == 2) {
            if (nums[0] > nums[1]) {
                int[] result = new int[2];
                result[0] = nums[1];
                result[1] = nums[0];
                return result;
             }
            return nums;
        }
        int length = nums.length / 2;
        int[] numsL = new int[length];
        System.arraycopy(nums, 0, numsL, 0, length);
        int lengthR = length + nums.length % 2;
        int[] numsR = new int[lengthR];
        System.arraycopy(nums, length, numsR, 0, lengthR);
        numsL = arrayPair(numsL);
        numsR = arrayPair(numsR);
        int[] numsA = new int[nums.length];
        int l = 0, r = 0;
        while (l < length || r < lengthR) {
            if (numsL[l] < numsR[r]) {
                numsA[l + r] = numsL[l];
                l++;
            } else {
                numsA[l + r] = numsR[r];
                r++;
            }
            if (l == length) {
                System.arraycopy(numsR, r, numsA, l + r, nums.length - l - r);
                break;
            }
            if (r == lengthR) {
                System.arraycopy(numsL, l, numsA, l + r, nums.length - l - r);
                break;
            }
        }
        return numsA;
    }
}

看了别人的解法，直接用java的现成方法， Java方法+证明， 快速排序，java中的源码还没有研究。

具体方法如下：

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

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 biggest Sm is the answer of this problem. Given 1, Sm = a1 + a2 + ... + an.
Denote Sa = a1 + b1 + a2 + b2 + ... + an + bn. Sa is constant for a given input.
Denote di = |ai - bi|. Given 1, di = bi - ai. Denote Sd = d1 + d2 + ... + dn.
So Sa = a1 + a1 + d1 + a2 + a2 + d2 + ... + an + an + di = 2Sm + Sd => Sm = (Sa - Sd) / 2. To get the max Sm, given Sa is constant, we need to make Sd as small as possible.
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.

还有更快的方法，时间复杂度O(n)，计数排序

public int arrayPairSum(int[] nums){
	 int [] counts = new int [20001];
	 for(int i=0;i<nums.length;i++){
		 counts[nums[i]+10000]++;
	 }
	 
	 
	 int cnt = 0;
	 int prevCnt = 0;
	 int res=0;
	 for(int i=0; i<counts.length;i++){
		 if(counts[i]==0)
			 continue;
		 prevCnt = cnt;
		 cnt +=counts[i];
	
		 if ((prevCnt & 1)!=0){//uneven
			 counts[i]--;
		 }
		 if((counts[i] & 1) == 0) {//even
			res+=(i-10000)*counts[i]/2; 
		 }
		 else{
			 res+=(i-10000)*(counts[i]/2+1);
		 }
	
	 }
	 return res;
  }