leetcode 321. Create Maximum Number

Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits.

Note: You should try to optimize your time and space complexity.

Example 1:

Input:
nums1 = [3, 4, 6, 5]
nums2 = [9, 1, 2, 5, 8, 3]
k = 5
Output:
[9, 8, 6, 5, 3]

给出两个数组，给出一个k，让输出一个长度为k的数组，元素从nums1，nums2中取，而且要保持在nums1和nums2中的顺序，使输出数组表示的整数最大

思路：
参照某大神的方法，把该问题分解成若干小问题。

(1) 从一个数组中取k个元素，使构成的整数最大
假如从nums2=[9,1,2,5,8,3]中取3个数字，且保持顺序，那么要取[9,8,3]
如何取：
k=3，数组中有6个元素，所以可以扔掉3个，定义为pop_num = 3
当pop_num > 0的时候，证明当前元素是可以扔掉的
比如已经保存了[9,1] 这时候来了2，比1大，所以扔掉1，pop_num = 2
又来了5，比2大，因为pop_num = 2 > 0, 再扔掉2，保存5
当pop_num = 0的时候就说明不能再扔了，后面所有都要保存。
（因为要保持顺序，所以不能说把大的保存在小的前面）

    public int[] maxNumber(int[] nums, int k) {
        if (k == 0) {
            return (new int[] {});
        }
        
        int pop_num = nums.length - k;
        int[] res = new int[nums.length];
        int index = -1;
        
        for (int i = 0; i < nums.length; i++) {
            while (index >= 0 && nums[i] > res[index] && pop_num > 0) {
                index --;
                pop_num --;
            }
            index ++;
            res[index] = nums[i];
        }
        
        
        return Arrays.copyOfRange(res, 0, k);
    }

（2）两个数组的元素拼成一个最大的数组
利用（1），假如已经从nums1中取得了[6, 5], nums2中取得了[9, 8, 3]
如何把它们拼成一个代表最大整数的数组：
这时候比较数组，不是那种先看长度的比较，而是顺序看元素大小，
一旦出现了nums1[i] < nums2[i], 就说明nums1 < nums2, 当前面所有元素一样时，再看谁更长
c++可以直接调用lexicographical_compare方法，java的话参照c++源码实现了一下lexicographical_compare方法

    //if nums1 < nums2, return true..
    public boolean compareArray(int[] nums1, int[] nums2, int first1, int last1, int first2, int last2) {
    	
    	while (first1 != last1) {
    		if (first2 == last2 || nums1[first1] > nums2[first2]) { //array1.len > array2.len => array1 > array2..
    			return false;
    		} else if (nums1[first1] < nums2[first2]) {
    			return true;
    		}
    		first1 ++;
    		first2 ++;
    	}
    
    	return (first2 != last2);
    }
    //return larger array..
    public int[] maxArray(int[] arr1, int[] arr2) {
    	if (compareArray(arr1, arr2, 0, arr1.length, 0, arr2.length)) {
    		return arr2;
    	} else {
    		return arr1;
    	}
    }

可以看出[6, 5] < [9, 8 ,3], 所以从[9,8,3]中取头一个元素9，
然后[6,5] < [8,3], 再取8
[6,5] > [3], 取6，依次类推

    public int[] maxNumber(int[] nums1, int[] nums2) {
    	int[] res = new int[nums1.length + nums2.length];
    	int index = 0;
    	
    	int first1 = 0;
    	int first2 = 0;
    	int last1 = nums1.length;
    	int last2 = nums2.length;
    	
    	while (first1 != last1 || first2 != last2) {
    		res[index] = compareArray(nums1, nums2, first1, last1, first2, last2) ? 
    		nums2[first2++] : nums1[first1++];
    		index ++;
    	}
    	
    	return res;
    }

当以上两个子问题解决之后，就可以解决这个取元素的问题了
假如在nums1中取i个元素，那么就要在nums2中取k-i个元素
就用到了

arr1 = maxNumber(nums1, i)
arr2 = maxNumber(nums2, k - i)

再用这两个得到的子数组拼成一个长度为k，且代表的整数最大的数组

arr = maxNumber(arr1, arr2)

每次都取较大的那个数组

res = max(res, arr)

完整版

//10ms
class CreateMaximumNumber {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
    	if (nums1 == null || nums1.length == 0) {
    		return Arrays.copyOfRange(nums2, 0, k);
    	}
    	
    	if (nums2 == null || nums2.length == 0) {
    		return Arrays.copyOfRange(nums1, 0, k);
    	}
    	
    	int[] res = new int[] {};
    	
    	for (int i = 0; i <= k; i ++) {
    		int j = k - i;
    		if (i > nums1.length || j > nums2.length) {
    			continue;
    		}
    		
    		res = maxArray(res, maxNumber(maxNumber(nums1, i), maxNumber(nums2, j)));
    	}    	
    	
        return res;        
    }
    
    private int[] maxNumber(int[] nums1, int[] nums2) {
    	int[] res = new int[nums1.length + nums2.length];
    	int index = 0;
    	
    	int first1 = 0;
    	int first2 = 0;
    	int last1 = nums1.length;
    	int last2 = nums2.length;
    	
    	while (first1 != last1 || first2 != last2) {
    		res[index] = compareArray(nums1, nums2, first1, last1, first2, last2) ? 
    				nums2[first2++] : nums1[first1++];
    		index ++;
    	}
    	
    	return res;
    }
    private int[] maxNumber(int[] nums, int k) {
        if (k == 0) {
            return (new int[] {});
        }
        
        int pop_num = nums.length - k;
        int[] res = new int[nums.length];
        int index = -1;
        
        for (int i = 0; i < nums.length; i++) {
            while (index >= 0 && nums[i] > res[index] && pop_num > 0) {
                index --;
                pop_num --;
            }
            index ++;
            res[index] = nums[i];
        }
        
        
        return Arrays.copyOfRange(res, 0, k);
    }
    
    //if nums1 < nums2, return true..
    private boolean compareArray(int[] nums1, int[] nums2, int first1, int last1, int first2, int last2) {
    	
    	while (first1 != last1) {
    		if (first2 == last2 || nums1[first1] > nums2[first2]) { //array1.len > array2.len => array1 > array2..
    			return false;
    		} else if (nums1[first1] < nums2[first2]) {
    			return true;
    		}
    		first1 ++;
    		first2 ++;
    	}
    
    	return (first2 != last2);
    }
    
    private int[] maxArray(int[] arr1, int[] arr2) {
    	if (compareArray(arr1, arr2, 0, arr1.length, 0, arr2.length)) {
    		return arr2;
    	} else {
    		return arr1;
    	}
    }
}