几道入门单调栈的LC题目

背景

最近随手练了几道leetcode，接触到了单调栈这种数据结构，在这里做个学习笔记。

单调栈是什么？

单调栈即满足单调性的栈结构，分为单调递增栈和单调递减栈。
单调递增栈：栈底到栈顶数据从大到小。
单调递减栈：栈底到栈顶数据从小到大。

单调栈应用

特别推荐这位大佬写的文章：一招吃遍力扣四道题，妈妈再也不用担心我被套路啦～.

思路讲得已经很清晰了，大佬用的python，我用的c++。尽管看了思路，但由于我太菜了，写代码的时候还是出现了很多bug，在这记录下来。

（1）402. 移掉K位数字

题目要求：给定一个以字符串表示的非负整数 num，移除这个数中的 k 位数字，使得剩下的数字最小。（详见：402. 移掉K位数字）

这个题目应该是这几题里最简单的一题了，刚看题目我也知道不能暴力求解，但是许久没练习过深度优先搜索遍历了，就想着练一下手，写得很菜，代码如下，提交果然超时了。正确解题思路看上面给出的大佬题解就可以。

class Solution {
private:
    string ans;
public:
    string removeKdigits(string num, int k) {
        int n = num.length() - k; //保留n位
        if(n == 0) return "0"; //特殊情况
        for(int i=0; i<n; i++){
            ans += "9"; //初始化为最大
        }
        string s;
        dfs(num, s, 0, n, 0);
        while(ans[0]=='0' && ans.length()>1) ans.erase(ans.begin()); //去掉前导0并注意特殊情况
        return ans;
    }
    void dfs(string num, string &s, int pos, int n, int cnt){
        if(cnt == n){
            if(s < ans) ans = s;
            return ;
        }
        for(int i=pos; i<num.length(); i++){
            s += num[i];
            dfs(num, s, i+1, n, cnt+1); //取
            s.erase(s.end()-1);
            dfs(num, s, i+1, n, cnt); //舍
        }
    }
};

（2）1081. 不同字符的最小子序列

题目要求：返回字符串text中按字典序排列最小的子序列，该子序列包含 text 中所有不同字符一次。（详见：1081. 不同字符的最小子序列）

解题思路可见题解。简而言之，就是一个特殊的单调栈，只有重复的字符可以pop，并且若已有相同字符入栈，该字符就不能再入栈了。

class Solution {
public:
    string smallestSubsequence(string s) {
    	// 注意这些变量什么时候需要改变
        map<char, int> mp; //字母剩余次数
        bool vis[26] = {false}; //是否已入栈
        stack<char> st; //单调栈
        for(int i=0; i<26; i++){
            mp['a'+i] = 0;
        }
        for(int i=0; i<s.length(); i++){
            mp[s[i]]++;
        }
        for(int i=0; i<s.length(); i++){
            if(vis[s[i]-'a']){ //已入栈 注意-'a'
                mp[s[i]]--;
                continue ;
            }
            while(!st.empty() && mp[st.top()]>1 && st.top()>s[i]){ //～
                mp[st.top()]--;
                vis[st.top()-'a'] = false;
                st.pop();
            }
            st.push(s[i]);
            vis[s[i]-'a'] = true;
        }
        string ans;
        while(!st.empty()){
            ans = st.top() + ans;
            st.pop();
        }
        return ans;
    }
};

这里还有同款题目：316. 去除重复字母

（3）321. 拼接最大数

题目要求：给定长度分别为m和n的两个数组，其元素由0-9构成，表示两个自然数各位上的数字。现在从这两个数组中选出k(k <= m+n)个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。求满足该条件的最大数。结果返回一个表示该最大数的长度为k的数组。
说明: 请尽可能地优化你算法的时间和空间复杂度。
（详见：321. 拼接最大数）

这道题是这几题中最复杂的，但是如果合理拆分问题，做起来还是没想象得那么困难。拆分问题能力绝不简单而且还很重要，希望我今后能多多思考。

我看了大佬思路后还是写了很久，才写下了下面还是很不成熟的代码。实际上，问题本质并没有发生变化。 假设我们从nums1中取了k1个，从num2中取了k2个，其中k1 + k2 = k。而k1和k2这两个子问题我们是会解决的。由于这两个子问题是相互独立的，因此我们只需要分别求解，然后将结果合并即可。我在maxNumber中遍历了k1和k2可能的取值，chooseN来解决两个子问题，并在merge函数中合并结果。

class Solution {
private:
    vector<int> chooseN(vector<int>& nums, int n){// 保证nums非空，n<=nums.size()
        vector<int> ans(n);
        if(n == 0) return ans;
        if(n == nums.size()) return nums;
        stack<int> st;
        while(!st.empty()) st.pop(); 
        int cnt = 0, drop = 0;
        for(int i=0; i<nums.size(); i++){
            //if(cnt == n) break;
            while(!st.empty() && st.top()<nums[i]){
                st.pop();
                cnt--;
                drop++;
                if(drop == nums.size()-n){ //已经丢掉了足够多
                    for(int j=i; j<nums.size(); j++){
                        st.push(nums[j]);
                        cnt++;
                    }
                    break;
                }
            }
            if(drop == nums.size()-n) break;
            st.push(nums[i]);
            cnt++;
        }
        while(cnt>n && !st.empty()){
            st.pop();
            cnt--;
        }
        for(int i=n-1; i>=0 && !st.empty(); i--){
            ans[i] = st.top();
            st.pop();
        }
        return ans;
    }
    vector<int> merge(vector<int>& nums1, vector<int>& nums2){
        int i=0, j=0;
        vector<int>  ans;
        while(i<nums1.size() && j<nums2.size()){
            if(nums1[i]>nums2[j]){
                ans.push_back(nums1[i]);
                i++;
            }
            else if(nums1[i]<nums2[j]){
                ans.push_back(nums2[j]);
                j++;
            }
            else{ // 特别注意相等的情况
                int m = i, n = j;
                while(++m<nums1.size() && ++n<nums2.size()){
                    if(nums1[m]>nums2[n]){
                        ans.push_back(nums1[i]);
                        i++;
                        break;
                    }
                    else if(nums1[m]<nums2[n]){
                        ans.push_back(nums2[j]);
                        j++;
                        break;
                    }
                }
                if(m>=nums1.size()){
                    ans.push_back(nums2[j]);
                    j++;
                }
                else if(n>=nums2.size()){
                    ans.push_back(nums1[i]);
                    i++;
                }
            }
        }
        while(i<nums1.size()){
            ans.push_back(nums1[i]);
            i++;
        }
        while(j<nums2.size()){
            ans.push_back(nums2[j]);
            j++;
        }
        return ans;
    }

public:
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        vector<int> ans, temp;
        int n1 = nums1.size(), n2 = nums2.size();
        for(int i=0; i<=min(n1, k); i++){
            int j = k - i;
            if(j > n2) continue;
            vector<int> ans1 = chooseN(nums1, i);
            vector<int> ans2 = chooseN(nums2, j);
            temp = merge(ans1, ans2);
            if(ans<temp) ans = temp;
        }
        return ans;
    }
};

总结

代码能力的提高还是多写写吧，不然手生随手一写就全是bug真让人哭泣。