拼接最大数

 

 

[image:1628696379919.png]
变量简洁正确完整思路
单调栈能够在保证相对顺序下，找到一个最大的组合，因为遇到更大的只要pop掉
前面较小的这就是单调栈，但是对长度有限制导致后半部分不用考虑pop不单调，
合并nums1nums2只需要大的放前面，但是相等，因为不是单调，所以需要一直往后面比较（易错），更新答案


class Solution {
public:
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        vector<int>ans;
        for(int i=0;i<=k;i++){
            if(i>nums1.size()||k-i>nums2.size())continue;
            //cout<<i<<k-i<<endl;
            vector<int>nums3=getNums(nums1,i);
            vector<int>nums4=getNums(nums2,k-i);
            //cout<<nums3.size()<<nums4.size()<<endl;
            vector<int>ans1=mergeNums(nums3,nums4);
            //for(int num:ans1)cout<<num<<' ';
            //cout<<endl;
            if(compareNums(ans,ans1))ans=ans1;
        }
        return ans;
    }
    bool compareNums(vector<int>&ans,vector<int>&ans1){
        int n=ans.size(),m=ans1.size();
        if(n<m)return true;
        if(n>m)return false;
        for(int i=0;i<n;i++){
            if(ans[i]<ans1[i])return true;
            if(ans[i]>ans1[i])return false;
        }
        return false;
    }
    vector<int>mergeNums(vector<int>&nums3,vector<int>&nums4){
        vector<int>ans;
        int i=0,j=0;
        //for(int num:nums3)cout<<num<<' ';
        //cout<<endl;
        //for(int num:nums4)cout<<num<<' ';
        //cout<<endl;
        while(i<nums3.size()||j<nums4.size()){
            if(j>=nums4.size()||i<nums3.size()&&nums3[i]>nums4[j]){
                ans.push_back(nums3[i]);
                i++;
            }else if(i>=nums3.size()||j<nums4.size()&&nums3[i]<nums4[j]){
                ans.push_back(nums4[j]);
                j++;
            }else if(nums3[i]==nums4[j]){
                //cout<<nums3[i]<<nums4[j]<<endl;
                int ii=i+1,jj=j+1;
                bool isNum3=false;
                while(1){
                    if(ii==nums3.size())break;
                    if(jj==nums4.size()){
                        isNum3=true;
                        break;
                    }
                    if(nums3[ii]>nums4[jj]){
                        isNum3=true;
                        break;
                    }
                    if(nums3[ii]<nums4[jj])break;
                    ii++,jj++;
                }
                if(isNum3){
                    ans.push_back(nums3[i]);
                    i++;
                }else {
                    ans.push_back(nums4[j]);
                    j++;
                }
            }
        }
        return ans;
    }

    vector<int>getNums(vector<int>&nums,int n){
        deque<int>deq;
        int drop=nums.size()-n;
        for(int i=0;i<nums.size();i++){
            while(!deq.empty()&&deq.back()<nums[i]){
                if(drop==0)break;
                deq.pop_back();
                drop--;
            }
            if(deq.size()<n)deq.push_back(nums[i]);
            else drop--;
        }
        vector<int>ans;
        while(!deq.empty()){
            ans.push_back(deq.front());
            deq.pop_front();
        }
        return ans;
    }
};

踩过的坑，超级大坑
合并两个数列，这两个数列并不是单调的，因为后面并不单调
所以相同的时候，并不是随便选一个，而是要继续往后比较，直到大的就合并