leetcode : 321. Create Maximum Number : 有点难度的贪心法

321. Create Maximum Number

My Submissions

Question

Total Accepted: 4587 Total
Submissions: 22666 Difficulty: Hard

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.
You should try to optimize your time and space complexity.
Example 1:

nums1 =

[3, 4, 6, 5]

nums2 =

[9, 1, 2, 5, 8, 3]

k =

5

return

[9, 8, 6, 5, 3]

Example 2:

nums1 =

[6, 7]

nums2 =

[6, 0, 4]

k =

5

return

[6, 7, 6, 0, 4]

Example 3:

nums1 =

[3, 9]

nums2 =

[8, 9]

k =

3

return

[9, 8, 9]

开始看题目，没有想法，肯定不会是暴力搜索所有可能的拼接。后来想到：如果能分别从两个数组中选出候选子集，那么就应该能够根据类似归并的样子，将其拼接成最大数组。但是，如何从一个数组中选出候选子集。瞄了一眼提示才知道：长度为subK候选子集就是在子数组中最大的子数组。

1.推论：假设数组x和数组y分别选出长度是r的subX和长度是(k-r)的subY组成的数组Z最大，并且保证元素保持原有的顺序（元素o在subX中哪些元素前后，在Z中仍然保持这样的顺序）。那么subX和subY分别是X，Y的固定长度的最大数组

原因很简单：贪心法证明，假设subX是拼接成最大数组Z的子数组，如果subX不是X的最大数组，那么存在subXX是X数组在固定长度的最大数组。subX和subY可以拼接成Z1，那么由subXX的数组元素来替换subX拼接成Z2，很明显Z2一定大于Z1。因此subX不是拼接成最大数组Z的子数组，与假设矛盾。因此，subX是X的最大数组。

既然知道subX是X中长度为r的最大数组，找出这个数组只要在元素的可能范围内选取最大元素，即可贪心法找出。

问题的下一步是：如何将两个最大数组合并成一个最大数组。开始的想法是：反正所有元素都要使用，使用类似归并法的方法，将大值尽可能排在前面即可。整体思路是对的，但是有个致命的bug：当遇到相等的比较，那么使用哪一个？一开始没有意识到这个问题，随便是用哪一个，结果wrong了好久。最后终于意识到，选择哪一个结果不一样的：

例如：

案例1：

5，3

5，8

案例2：

5，5，8

5，8

案例3：

5

5，8

案例4：

5，5，3，7，9

5，5，3，7，8

等考虑完成这些情况后，调试AC

public class Solution {
public int[] submax(int[]numx,int subk){
if(subk>numx.length||subk==0)
return null;
if(subk==numx.length)
return numx;
int[] subre=new int[subk];
int left=0,right=numx.length-subk;
for(int i=0;i<subk;i++){
int max=Integer.MIN_VALUE;
int maxIndex=-1;
for(int j=left;j<=right;j++){
if(max<numx[j]){
max=numx[j];
maxIndex=j;
}
}
if(maxIndex!=-1){
subre[i]=max;
left=maxIndex+1;
right++;
}
}
return subre;
}
public int[] merge(int[] sub1,int[] sub2){
if(sub1==null||sub2==null)
return sub1!=null?sub1:sub2;
int len1=sub1.length;
int len2=sub2.length;
int len=len1+len2;
int[] mergeList=new int[len];
int i=0,j=0;
int index=0;
while(i<len1&&j<len2){
if(sub1[i]<sub2[j])
mergeList[index++]=sub2[j++];
else {
if(sub1[i]>sub2[j])
mergeList[index++]=sub1[i++];
else {
int equalNum;
boolean find=false;
for(equalNum=1;i+equalNum<len1&&j+equalNum<len2;equalNum++){
if(sub1[i+equalNum]!=sub2[j+equalNum]){
find=true;break;
}
}
if(!find&&(i+equalNum<len1||j+equalNum<len2))
find=true;
if(find){
int whichone=0;
if(i+equalNum>=len1||j+equalNum>=len2)
whichone=i+equalNum<len1?1:2;
else {
whichone=sub1[i+equalNum]<sub2[j+equalNum]?2:1;
}
mergeList[index++]=whichone==1?sub1[i++]:sub2[j++];
}
else {
mergeList[index++]=sub1[i++];
}
}
}
}
while(i<len1)
mergeList[index++]=sub1[i++];
while(j<len2)
mergeList[index++]=sub2[j++];
return mergeList;
}
public int comparIntList(int[] first,int[] second){
if(first.length!=second.length)
return first.length-second.length;
for(int i=0;i<first.length;i++)
if(first[i]!=second[i]){
return first[i]-second[i];
}
return 0;
}
public int[] maxNumber(int[] nums1, int[] nums2, int k) {
int[] re=new int[k];
int[] subre1,subre2;
int len1=nums1.length;
int len2=nums2.length;
if(k>len1+len2)
return null;
int minNum1=k-len2<0?0:k-len2;
int maxNum1=len1<k?len1:k;
for(int i=minNum1;i<=maxNum1;i++){
subre1=submax(nums1, i);
subre2=submax(nums2, k-i);
int[] temp=merge(subre1,subre2);
if(i==minNum1||comparIntList(temp,re)>0){
System.arraycopy(temp, 0, re, 0, k);
}
}
return re;
}
}

实际上，针对相等比较的情况，需要比较的是剩余数组的大小，然后对大的数组，压一个元素进结果数据。隔壁家的代码就是精炼

public int[] maxNumber(int[] nums1, int[] nums2, int k) {
int n = nums1.length;
int m = nums2.length;
int[] ans = new int[k];
for (int i = Math.max(0, k - m); i <= k && i <= n; ++i) {
int[] candidate = merge(maxArray(nums1, i), maxArray(nums2, k - i), k);
if (greater(candidate, 0, ans, 0)) ans = candidate;
}
return ans;
}
private int[] merge(int[] nums1, int[] nums2, int k) {
int[] ans = new int[k];
for (int i = 0, j = 0, r = 0; r < k; ++r)
ans[r] = greater(nums1, i, nums2, j) ? nums1[i++] : nums2[j++];
return ans;
}
public boolean greater(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]);
}
public int[] maxArray(int[] nums, int k) {
int n = nums.length;
int[] ans = new int[k];
for (int i = 0, j = 0; i < n; ++i) {
while (n - i + j > k && j > 0 && ans[j - 1] < nums[i]) j--;
if (j < k) ans[j++] = nums[i];
}
return ans;
}