每日算法26_2020-12-02

来源：题库 - 力扣 (LeetCode) (leetcode-cn.com)。侵删。

题目一

321. 拼接最大数

给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。

求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。

说明: 请尽可能地优化你算法的时间和空间复杂度。

示例 1:

输入:
nums1 = [3, 4, 6, 5]
nums2 = [9, 1, 2, 5, 8, 3]
k = 5
输出:
[9, 8, 6, 5, 3]
示例 2:

输入:
nums1 = [6, 7]
nums2 = [6, 0, 4]
k = 5
输出:
[6, 7, 6, 0, 4]
示例 3:

输入:
nums1 = [3, 9]
nums2 = [8, 9]
k = 3
输出:
[9, 8, 9]

我没做出来，参考https://leetcode-cn.com/problems/create-maximum-number/comments/83504这个人的答案，算是理解这题该怎么做了。

class Solution {
/*
假设数组一为[3,4,6,5]、数组二为[9,1,2,5,8,3]、k = 5;
组合情况有0 + 5、1 + 4、2 + 3、3 + 2、4 + 1五种情况,就是从此五种情况取出组合最大的一种;
*/
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int m = nums1.length, n = nums2.length;
        int[] res = new int[k]; // 返回的数组
        
        // Math.max(0, k - n)表示若数组二的元素个数n >= k时,则数组一的元素个数可以从0开始取,否则在数组二的大小基础上补.
        for (int i = Math.max(0, k - n); i <= k && i <= m; i++) {
            // 上来i = 0，则merge(maxArr(nums1, 0), maxArr(nums2, 5), 5) 是 0 + 5的情况。后续依次类推
            int[] arr = merge(maxArr(nums1, i), maxArr(nums2, k - i), k);
            
            // 判断可是最大这种组合情况下得到的数组可是最大的数组，是就替换掉返回数组
            if (gt(arr, 0, res, 0)) res = arr;
        }
        return res;
    }
    
    private int[] maxArr(int[] nums, int k) {
        // 假设选择了2 + 3的情况,分别从两个数组取出相应元素个数的最大组合，对数组一来说就是[6,5],对数组二来说是[9,8,3];
        // 那么先对数组1[3, 4, 6, 5]来说, k=2
        int n = nums.length; // n = 4
        int[] res = new int[k]; // k=2的数组 
        
        for (int i = 0, j = 0; i < n; i++) {
            /*
            对与这个while，上来n=4,i=j=0,k=2
            那么 n-i+j=4-0+0=4,4>2 满足，j>0不满足，故不循环
            接着j<k 0<2，满足 res[0] = nums1[0] = 3, j++ = 1, i++ = 1
            
            第二个while，n=4,k=2,i=j=1
            那么 n-i-j=4-1+1=4,4>2 满足，j>0 1>0 满足 nums[1] > res[1-1] = 4 > 3 满足，j--，j=0
            while循环，n=4,k=2,i=1,j=0
            那么 n-i-j=4-1+0=4,3>2 满足，j>0 0>0 不满足 跳出循环
            接着 j<k 0<2 满足 res[0] = nums1[1] = 4, j++ = 1, i++ = 2
            
            第三个while，n=4,k=2,i=2 j=1
            那么 n-i+j=4-2+1=0,3>2，满足，j>0 1>0满足 nums[2] > res[1-1] = 6 > 4 满足 ,j--,j=0
            while循环，n=4,k=2,i=2,j=0
            那么 n-i-j=4-2+0=4,2>2 不满足 跳出循环
            接着 j<k 0<2 满足 res[0] = nums1[2] = 6, j++ = 1, i++ = 3
            
            第四个while，n=4,k=2,i=3,j=1
            那么n-i+j=4-3+1=2,2>2 不满足
            接着 j<2 1<2 满足，res[1] = nums[3] = 5 j++ = 2,i++ = 4  i<n = 4<4 跳出for循环
        
            那么这时res = [6, 5]，很明显是最大值
             */
            while (n - i + j > k && j > 0 && nums[i] > res[j-1]) j--;
            if (j < k) res[j++] = nums[i];
            /*
            那么可以总结出，i 是在控制在nums上依次选数的指针，
            而while上的条件是在刚放进res中的数可比nus后续的值小，即对数数组[3,4,6,5]，放3就要判断4，放4就要判断6，只要大就j--，那么下面就还是在之前的res位置上放值
            同时while还要控制到6,5了不至于会超出范围，即不要5替换6
            简单的说，就是
                    res[0,0] nums[3,4,6,5] i指向3 j指向res第一个0
                    res[3,0] nums[3,4,6,5] i指向4 j指向res中的3 4>3 替换
                    res[4,0] nums[3,4,6,5] i指向6 j指向res中的4 6>4 替换
                    res[6,0] nums[3,4,6,5] i指向5 j指向res中的6 由于nums中5已经是最后一个值了
                    res[6,5] 直接放在第二个位置上，直接返回
            */
        }
        
        return res;
    }

    /*
    假设数组一最大组合为[6,5],数组二最大组合为[9,8,3],进行双指针排序,排序后为[9,8,6,5,3]
     */
    private int[] merge(int[] nums1, int[] nums2, int k) {
        int[] res = new int[k];
        for (int i = 0, j = 0, r = 0; r < k; r++)
            res[r] = gt(nums1, i, nums2, j) ? nums1[i++] : nums2[j++];
        return res;
    }

    /*
    比较两数组相应位置大小,相等就一直跳过,直到不相等就比较.
     */
    private boolean gt(int[] nums1, int i, int[] nums2, int j) {
        while (i < nums1.length && j < nums2.length && nums1[i] == nums2[j]) {
            i++;
            j++;
        }
        return j == nums2.length || (i < nums1.length && nums1[i] > nums2[j]);
    }
}

官方答案方法一：单调栈

为了找到长度为 k 的最大数，需要从两个数组中分别选出最大的子序列，这两个子序列的长度之和为 k，然后将这两个子序列合并得到最大数。两个子序列的长度最小为 0，最大不能超过 k 且不能超过对应的数组长度。

令数组nums1的长度为 m，数组nums2的长度为 n，则需要从数组nums1中选出长度为 x 的子序列，以及从数组 nums2中选出长度为 y 的子序列，其中x+y=k，且满足 0≤x≤m 和0≤y≤n。需要遍历所有可能的 x 和 y 的值，对于每一组 x 和 y 的值，得到最大数。在整个过程中维护可以通过拼接得到的最大数。

对于每一组 x 和 y 的值，得到最大数的过程分成两步，第一步是分别从两个数组中得到指定长度的最大子序列，第二步是将两个最大子序列合并。

第一步可以通过单调栈实现。单调栈满足从栈底到栈顶的元素单调递减，从左到右遍历数组，遍历过程中维护单调栈内的元素，需要保证遍历结束之后单调栈内的元素个数等于指定的最大子序列的长度。遍历结束之后，将从栈底到栈顶的元素依次拼接，即得到最大子序列。

第二步需要自定义比较方法。首先比较两个子序列的当前元素，如果两个当前元素不同，则选其中较大的元素作为下一个合并的元素，否则需要比较后面的所有元素才能决定选哪个元素作为下一个合并的元素。

在下面的代码中，单调栈使用数组实现，数组最左侧为栈底。使用数组实现，可以直接从左到右遍历数组得到最大子序列。

class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int m = nums1.length, n = nums2.length;
        int[] maxSubsequence = new int[k];
        int start = Math.max(0, k - n), end = Math.min(k, m);
        for (int i = start; i <= end; i++) {
            int[] subsequence1 = maxSubsequence(nums1, i);
            int[] subsequence2 = maxSubsequence(nums2, k - i);
            int[] curMaxSubsequence = merge(subsequence1, subsequence2);
            if (compare(curMaxSubsequence, 0, maxSubsequence, 0) > 0) {
                System.arraycopy(curMaxSubsequence, 0, maxSubsequence, 0, k);
            }
        }
        return maxSubsequence;
    }

    public int[] maxSubsequence(int[] nums, int k) {
        int length = nums.length;
        int[] stack = new int[k];
        int top = -1;
        int remain = length - k;
        for (int i = 0; i < length; i++) {
            int num = nums[i];
            while (top >= 0 && stack[top] < num && remain > 0) {
                top--;
                remain--;
            }
            if (top < k - 1) {
                stack[++top] = num;
            } else {
                remain--;
            }
        }
        return stack;
    }

    public int[] merge(int[] subsequence1, int[] subsequence2) {
        int x = subsequence1.length, y = subsequence2.length;
        if (x == 0) {
            return subsequence2;
        }
        if (y == 0) {
            return subsequence1;
        }
        int mergeLength = x + y;
        int[] merged = new int[mergeLength];
        int index1 = 0, index2 = 0;
        for (int i = 0; i < mergeLength; i++) {
            if (compare(subsequence1, index1, subsequence2, index2) > 0) {
                merged[i] = subsequence1[index1++];
            } else {
                merged[i] = subsequence2[index2++];
            }
        }
        return merged;
    }

    public int compare(int[] subsequence1, int index1, int[] subsequence2, int index2) {
        int x = subsequence1.length, y = subsequence2.length;
        while (index1 < x && index2 < y) {
            int difference = subsequence1[index1] - subsequence2[index2];
            if (difference != 0) {
                return difference;
            }
            index1++;
            index2++;
        }
        return (x - index1) - (y - index2);
    }
}

复杂度分析

• 时间复杂度：O(k(m+n+k^2 ))，其中 m 和 n 分别是数组nums1 和 nums2的长度，k 是拼接最大数的长度。
  两个子序列的长度之和为 k，最多有 k 种不同的长度组合。对于每一种长度组合，需要首先得到两个最大子序列，然后进行合并。
  得到两个最大子序列的时间复杂度为线性，即 O(m+n)。
  合并两个最大子序列，需要进行 k 次合并，每次合并需要进行比较，最坏情况下，比较的时间复杂度为 O(k)，因此合并操作的时间复杂度为 O(k^2)。
  因此对于每一种长度组合，时间复杂度为 O(m+n+k^2)，总时间复杂度为 O(k(m+n+k^2))。

• 空间复杂度：O(k)，其中 kk 是拼接最大数的长度。每次从两个数组得到两个子序列，两个子序列的长度之和为 k。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/create-maximum-number/solution/pin-jie-zui-da-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。