Leetcode.321 拼接最大数

题目链接

Leetcode.321 拼接最大数 hard

题目描述

给定长度分别为 $m$ 和 $n$ 的两个数组，其元素由 $0\sim 9$ 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 $k$ $(k\le 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]

解法：单调栈

我们假设由 $k$ 个元素组成的最大数，其中有 $x$ 个元素来自 $nums1$，那么就有 $k-x$ 个元素来自 $nums2$。

我们定义 $max\_sequence(S,m)$ 表示从集合 $S$ 中，选出 $m$ 个元素构成的最大数（元素之间要保持在集合 $S$ 中的相对位置）。

• $s1=max\_sequence(nums1,x)$，$s1$ 表示从集合 $nums1$ 中选出 $x$ 个元素组成的最大数；
• $s2=max\_sequence(nums2,k-x)$，$s2$ 表示从集合 $nums2$ 中选出 $k-x$ 个元素组成的最大数；

我们最后再将 $s1$ 和 $s2$ 拼接成一个最大数 $S$，那么这个 $S$ 就是答案之一。所以我们就要遍历 $x$ ，求出所有的 $S$，最后返回最大的那个。

在实现上：

$max\_sequence(S,m)$ 可以利用单调栈实现：

• 如果 $S.size()\le m$，那么直接返回集合 $S$ 即可；
• 我们定义一个栈 $stk$，因为我们要返回的是 $m$ 个元素组成的最大数，也就是说 $stk$ 最终有 $m$ 个元素，即 $stk$ 能够弹出去的元素最多只有 $del=S.size()-m$ 个。
• 假设当前遍历到的元素为 $x$，如果 $x>stk.top()$ 并且 $del>0$，那么就可以弹出栈顶元素，因为我们要是$stk$ 中的数字典序尽可能的大。
• 最终返回 $stk$ 即可。需要注意的是：如果 $S$ 中所有元素都相同 或者 $S$ 是一个非降序的序列，那么 $stk$ 中就没有弹出的元素，一共就有 $S.size()$ 个元素，我们只需要前 $m$ 个即可。

在这里需要介绍一个 STL algorithm 库的函数 lexicographical_compare(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)

template<class InputIt1, class InputIt2>
bool lexicographical_compare(InputIt1 first1, InputIt1 last1,
                             InputIt2 first2, InputIt2 last2)
{
    for (; (first1 != last1) && (first2 != last2); ++first1, (void) ++first2)
    {
        if (*first1 < *first2)
            return true;
        if (*first2 < *first1)
            return false;
    }
 
    return (first1 == last1) && (first2 != last2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上述这个函数的作用是：判断区间一 $[first1,last1)$ 字典序是否不大于 区间二$[first2,last2)$。

• 是的话，最终返回 true；
• 否，返回 false；

时间复杂度： $O(m+n+k^2)$

C++代码：

class Solution {
public:
    vector<int> max_sequence(vector<int> vec,int k){
        int n = vec.size();
        if(n <= k) return vec;

        vector<int> stk;
        int del = n - k;

        for(int i = 0;i < n;i++){
            while(stk.size() && vec[i] > stk.back() && del){
                del--;
                stk.pop_back();
            }
            stk.push_back(vec[i]);
        }

        stk.resize(k);

        return stk;
    }
    
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        int m = nums1.size() , n = nums2.size();
        vector<int> res(k,0);

        for(int x = max(0,k - n);x <= min(k,m);x++){
            vector<int> temp;
            auto s1 = max_sequence(nums1,x);
            auto s2 = max_sequence(nums2,k - x);

            auto it1 = s1.begin() , it2 = s2.begin();
            while(it1 != s1.end() || it2 != s2.end()){
                temp.push_back(lexicographical_compare(it1,s1.end(),it2,s2.end() )? *it2++ : *it1++);
            }
            res = lexicographical_compare(res.begin(),res.end(),temp.begin(),temp.end()) ? move(temp) : res;
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40