Leetcode - Create Maximum Number

My code:

public class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        if (nums1 == null || nums2 == null || nums1.length + nums2.length < k) {
            return null;
        }
        
        int[] ret = null;
        int max = 0;
        for (int i = 0; i <= k; i++) {
            int[] n1 = pick(nums1, i);
            int[] n2 = pick(nums2, k - i);
            if (n1 == null || n2 == null) {
                continue;
            }
            int[] m = merge(n1, n2);
            ret = getSum(m, ret);
        }
        
        return ret;
    }
    
    private int[] pick(int[] nums, int k) {
        if (nums.length < k) {
            return null;
        }
        
        int[] ret = new int[k];
        int cursor = 0;
        for (int i = 0; i < nums.length; i++) {
            while (cursor > 0 && nums[i] > ret[cursor - 1] && cursor + nums.length - i - 1 >= k) {
                cursor--;
            }

            if (cursor < k) {
                ret[cursor] = nums[i];
                cursor++;
            }
        }
        
        return ret;
    }
    
    private int[] merge(int[] n1, int[] n2) {
        int l1 = n1.length;
        int l2 = n2.length;
        int[] ret = new int[l1 + l2];
        int i = 0;
        int j = 0;
        for (int k = 0; k < ret.length; k++) {
            if (bigger(n1, i, n2, j)) {
                ret[k] = n1[i];
                i++;
            }
            else {
                ret[k] = n2[j];
                j++;
            }
        }
        return ret;
    }
    
    private boolean bigger(int[] n1, int i, int[] n2, int j) {
        while (i < n1.length && j < n2.length) {
            if (n1[i] < n2[j]) {
                return false;
            }
            else if (n1[i] > n2[j]) {
                return true;
            }
            else {
                i++;
                j++;
            }
        }
        
        return i != n1.length;
    }
    
    private int[] getSum(int[] nums, int[] ret) {
        if (ret == null) {
            return nums;
        }
        
        if (nums.length > ret.length) {
            return nums;
        }
        else if (nums.length < ret.length) {
            return ret;
        }
        else {
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] > ret[i]) {
                    return nums;
                }
                else if (nums[i] < ret[i]) {
                    return ret;
                }
            }
            return ret;
        }
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        int[] nums1 = new int[]{2, 5, 6, 4, 4, 0};
        int[] nums2 = new int[]{7, 3, 8, 0, 6, 5, 7, 6, 2};
        int[] ret = test.maxNumber(nums1, nums2, 15);
        for (int i = 0; i < ret.length; i++) {
            System.out.print(ret[i] + "_");
        }
    }
}

这道题目思考了一会儿，觉得没有思路。然后看了答案的提示。
然后尝试着自己写出来。写了很久，最后卡在了
merge函数的地方。
慢慢说来。

reference:
https://www.hrwhisper.me/leetcode-create-maximum-number/

我自己也很自然的想到，可以写一个循环，然后分割。
arr1 取出 i
arr2 取出 k - i
如何让值最大

那么这个大问题就可以分解为多个子问题，然后求出最大解就可以了。

下面分析这个问题：
arr1 取出 i
arr2 取出 k - i
如何让值最大

他又可以分成三个问题：

1. 从 arr 取出 i 位，如果保证取出的是最大的
2. 现在有 arr1, arr2, 如何merge 成最大的 (这个问题最难，然后一开始我以为最简单，以为就是 Merge sort)
3. 如何计算合并后的arr的值 (这里会存在over flow,因为，arr可能有40位或者更多，Long都不会够，所以得用其他的比较方法)

首先解决问题1：
其实就是一个栈的问题。
当 stack.size() < k 的时候，我不断地插入新的元素。
当 = k 时，我可以判断当前元素nums[i] 是否大于栈顶元素：
stack.peek()
错！ 一开始我也这么想的，这是不对的！

我维持一个栈，当栈空时，直接插，不空时，
判断 当前元素nums[i] 是否大于栈顶元素：
stack.peek()
如果小于，
如果栈size小于k，那就直接插，i继续走。
否则就直接忽略。
如果大于，那么就要复杂的思考下了。
按道理说，就该把栈顶弹出，然后把这个插进去。
但如果剩下的元素个数如果已经小于我们还需要的个数时，就凑不满了，那么这个时候就不能弹出，只能忽略，继续往前走。

简而言之，

如果 指针 i 指向 nums[] 的当前元素
指针cursor指向 ret[] 的当前元素 （就是栈）

if (cursor > 0 && nums[i] > ret[cursor - 1] && cursor + nums.length - i >= k)
{
      cursor--;
}

这里，cursor - 1 指的是栈顶，
cursor = stack size
所以如果弹出，然后插入新的元素，
我们还需要的元素个数是：
k - cursor
我们还剩下可供选择的元素个数是：
nums.length - i

k - cursor <= nums.length - i
=>
cursor + nums.length - i >= k

那么这个时候，我们就可以弹出了。
以此作为一个while循环，不断地更新这个栈，直到是当前最优值。

那么第一个问题解决了。

第二个问题，如何合并。
我一开始以为是简单地merge sort，后来发现不是。
[3, 3, 4]
[3, 3]

当 arr1[i] == arr2[j]时，在merge sort中是可以任意先让哪个指针先走的。
这里的话，其实不是merge sort，只是将两个数组合并，保持他们原有的顺序，并且使得值最大。

那么应该是，
3, 3, 4, 3, 3

所以，需要判断哪个数组更大，更大的话就走哪个。
也就是说， arr1[i] > or < arr2[j] 时，一切照常

如果 arr1[i] == arr2[j] 时，需要一直遍历这两个数组，直到找到一个元素，两者不等，或者其中一个数组被穷尽。

第二个问题也算是解决了。

第三个问题，如果比较大小。
最后还是打算用字符串来做这件事，方便安全。
也解决了。

这道题目的考虑点还是很多的。我觉得有用的是第一二两个问题的答案。

如何从 arr[] 中选出 k个，顺序组成一个数字，最大

如何 merge arr1[] and arr2[] ，保持他们的顺序，使其组成的数字最大。

Anyway, Good luck, Richardo! -- 08/25/2016