单调栈解决维持相对位置不变最小/最大字典序问题

多次碰到这类维持相对位置不变，删除某些元素维持最小or最大字典序问题，这里记录一下：

首先给出一个经典的例子：

我们想要维持最小或者最大，无非是要保持相对有序的情况下，保持一个递增或者递减栈，其实就是一个单调栈的问题，上题中的移除K个元素使得最后的剩下的数字最小，题目是想告诉你维持一个单调递增栈。
分析：对于1432219这种情况，第一个元素1，由于栈内没有其他元素，所以入栈，第二个元素4，栈内递增，不用管，第三个元素3，此时不是递增，需要把4出栈，再把3入栈，由于我们最多只能删除K个元素，所以当出栈元素个数到达K的时候，不再删除元素。有一个极端情况，也就是整个数组都是递增的，这种情况下，不需要删除任何元素，所以我们直接取前面len-k个元素即可，len为数组长度。

代码如下：

class Solution {
    public String removeKdigits(String num, int k) {
        int len = num.length();
        if(len <= k) return "0";
        char[] ch = num.toCharArray();
        String res = "";
        int remain = len-k;
        Deque<Character> stack = new LinkedList<>();
        for(char c: ch){
            while(!stack.isEmpty() && stack.peek() > c && k > 0){
                stack.pop();
                k--;
            }
            stack.push(c);
        }
        int size = 0; 
        while(remain-- > 0) { // 取len-k个元素
            char t = stack.pollLast(); 
            if(size == 0 && t == '0') continue;  // 注意前面为0的情况
            res+=t;
            size++;
        }
        return size == 0?"0":res; //为空的情况
    }
}

---

这道题也是类似的，只不过上题中的k，这题换成了每个元素的频率即为每个k，情况有点不一样了，但还是可以解决：我们首先需要记录每个元素的频率，同样也是维持一个单调队列，不同的是，当栈内有该元素以及栈顶元素的频率降到0了，就不可以出栈了

class Solution {
    public String removeDuplicateLetters(String s) {
        int len = s.length();
        if(len == 0) return s;
        char[] count = new char[26];
        for(char ch: s.toCharArray()) count[ch-'a'] ++;
        boolean[] instack = new boolean[26];
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i<len; i++){
            char ch = s.charAt(i);
            count[ch-'a'] --;
            if(instack[ch-'a']) continue;
            while(!stack.isEmpty() && stack.peek() >= ch){
                if(count[stack.peek()-'a'] == 0) break;
                instack[stack.peek()-'a'] = false;
                stack.pop();
            }
            stack.push(ch);
            instack[ch-'a'] = true;
        }
        StringBuffer sb = new StringBuffer();
        while(!stack.isEmpty()) sb.append(stack.pop());
        return sb.reverse().toString();
    }
}

这题和 1081. 不同字符的最小子序列是一样的

---

class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        if(k >= len1 + len2) return merge(nums1, nums2);
        int[] res = new int[k];
        for(int i = 0; i<=k; i++){
            if(i > len1) continue;
            int[] nn1 = getKArray(nums1, i);
            if(k-i > len2) continue;
            int[] nn2 = getKArray(nums2, k-i);
            int[] nn3 = merge(nn1, nn2);
            if(compare(nn3,0,res,0) > 0){
                res = Arrays.copyOf(nn3, k);
            }
        }        
        return res;
    }
    public int[] merge(int[] nums1, int[] nums2){  // 合并两个数组
        int len1 = nums1.length;
        int len2 = nums2.length;
        int[] res = new int[len1+len2];
        int index = 0, i = 0, j = 0;
        while(i<len1 || j<len2){
            if(i >= len1){
                res[index++] = nums2[j++];
                continue;
            }
            if(j >= len2){
                res[index++] = nums1[i++];
                continue;
            }
            if(compare(nums1,i,nums2,j) > 0){
                res[index++] = nums1[i++];
            }else{
                res[index++] = nums2[j++];
            }
        }
        return res;
    }
    public int[] getKArray(int[] nums, int k){ // 就是上面那题去掉K个数
        int[] res = new int[k];
        int remain = nums.length-k;
        Deque<Integer> deque = new LinkedList<>();
        for(int i = 0; i<nums.length; i++){
            while(!deque.isEmpty() && deque.peekLast() < nums[i] && remain > 0){
                deque.pollLast();
                remain--;
            }
            deque.offerLast(nums[i]);
        }
        int index = 0;
        while(k > 0 && !deque.isEmpty()) {
            res[index++] = deque.pollFirst();
            k--;
        }
        return res;
    }
    public int compare(int[] nn1, int index1, int[] nn2, int index2){
        while(index1 < nn1.length || index2 < nn2.length){
            if(index1 >= nn1.length) return -1;
            if(index2 >= nn2.length) return 1;
            if(nn1[index1] != nn2[index2]){
                return nn1[index1]-nn2[index2];
            }else{
                index1++;
                index2++;
            }
        }
        return 0;
    }
}

看起来蛮长的，其实就是上面移掉K位数的一个变形，我们通过遍历 i 和 j，其中i为第一个数组需要取的K位数，j为第二个数组需要取的K位数，通过遍历它们，取最大的数组，这里需要注意合并的时候，比较的问题，这里写的compare函数就是合并比较