两个贪心算法——Leetcode321拼接最大数和Leetcode316去除重复字母

贪心算法和梯度下降法很像，每一步取当前最优解。但是得保证每一步取最优解，最后会取到全局最优解。

首先看Leetcode316，去除重复字母。题目是这样的：

给定一个仅包含小写字母的字符串，去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。

示例 1:

输入: "bcabc"
输出: "abc"
示例 2:

输入: "cbacdcbc"
输出: "acdb"

字典序最小，所以得越小的字母在越前面。可以设计一个栈，不停往里面塞字符，如果当前字符比栈顶要小，就弹出栈顶字符。不过弹出之前，还需要确认后面还会不会有这个字符，如果后面没有的话，就不能弹出来了。具体对每一个字母设计一个计数器，然后再用一个标记标注有没有塞到栈里面。这个栈直接用string就可以实现了。

class Solution {
public:
    string removeDuplicateLetters(string s) {
        unordered_map<char, int> dict;//key: letter, value: how many letter remaining in current string
        unordered_map<char, bool> exist;//key: letter, value: whether the letter has been put in ans
        for(int i='a'; i<='z'; i++){
            dict[i] = 0;
            exist[i] = false;
        }
        for(char c: s){
            dict[c]++;
        }
        
        string ans = "";
        for(char c: s){
            if(!exist[c]){// if current c not in ans
                while(!ans.empty() && c < ans.back() && dict[ans.back()] > 0){
                    exist[ans.back()] = false;
                    ans.pop_back();
                }
                ans.push_back(c);
                exist[c] = true;
            }
            dict[c]--;
        }
        return ans;
    }
};

对于Leetcode 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]

我们可以这么思考这个过程，从num1里面取i个数字，从num2里取k-i个数字，然后把这两个数组拼接起来，遍历i，就得到结果。

首先是i的取值范围需要注意，有两个不等式：

0 <= i <= n1

0 <= k-i <= n2   ==》    k - n2 <= i <= k

显然：i需要同时满足上面两个不等式，所以   max(0, k-n2) <= i <= min(k, n1)。其中n1和n2是两个数组的长度。

第二个问题是如何从num1里面取i个数字。要保证最大值，所以越靠前面的，就要越大。这其实和leetcode316一模一样，实际上，就是从nums1里面删除n1-i个数字，达到最大字典序。解法和上面完全相同。

最后一个问题是已经有了长度为i和长度为k-i的数组，如何拼接在一起。

这里使用双指针的方法，比如指针为ii, jj，这里用ii和jj为了和上面的i分开。取ii和jj指向的数中更大的那个值，然后把对应的指针往后移动一步。但是这样有一个问题，如果两个指针指向的数字相等怎么办？这样我们就判断后面的数字。

如果ii和jj处的值相等，同时往后移动，直到不相等为止，然后判断哪个更大。

这里又有一个问题，如果ii或者jj到了末尾，都还是相等怎么办。这样就取还没有到末尾的那一个指针，因为没有到末尾，后面还有可能比当前数字更大的数。

实现代码如下：

class Solution {
public:
    bool cmp(vector<int> &nums1, vector<int> &nums2){
        //return true : nums1 > nums2
        if(nums1.size() != nums2.size())
            return nums1.size() > nums2.size();
        for(int i=0; i<nums1.size(); i++){
            if(nums1[i] > nums2[i]){
                return true;
            }
            if(nums1[i] < nums2[i]){
                return false;
            }
        }
        return false;
    }
    vector<int> get(vector<int>& nums, int s){
        vector<int> ans;
        int n = nums.size();
        int todrop = n - s;
        for(int n: nums){
            while(!ans.empty() && n > ans.back() && todrop > 0) {
                ans.pop_back();
                todrop--;
            }
            ans.push_back(n);
        }
        ans.resize(s);
        return ans;
    }
    bool greater(vector<int> nums1, vector<int> nums2, int i, int j){
        if(nums1[i] > nums2[j]){
            return true;
        } else if(nums1[i] < nums2[j]){
            return false;
        }
        while(i < nums1.size() && j < nums2.size() && nums1[i] == nums2[j]){
            i++;
            j++;
        }
        return j == nums2.size() || (i < nums1.size() && nums1[i] > nums2[j]);
    }
    vector<int> merge(vector<int>nums1, vector<int> nums2){
        vector<int> ans;
        int i = 0, j = 0;
        int n1 = nums1.size(), n2 = nums2.size();
        while(i < n1 && j < n2){
            if(nums1[i] > nums2[j]){
                ans.push_back(nums1[i++]);
            } else if(nums1[i] < nums2[j]) {
                ans.push_back(nums2[j++]);
            } else {
                if(greater(nums1, nums2, i, j)){
                    ans.push_back(nums1[i++]);
                } else {
                    ans.push_back(nums2[j++]);
                }
            }
        }
        while(i < n1){
            ans.push_back(nums1[i++]);
        }
        while(j < n2){
            ans.push_back(nums2[j++]);
        }
        return ans;
    }
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        vector<int> ans;
        int n1 = nums1.size(), n2 = nums2.size();
        for(int i = max(0, k-n2); i <= min(n1, k); i++){
            vector<int> tmp = merge(get(nums1, i), get(nums2, k-i));
            ans = cmp(tmp, ans) ? tmp : ans;
        }
        return ans;
    }
};