贪心+单调栈（Leetcode 402+316+321+1081）

贪心+单调栈（Leetcode 402+316+321+1081）

这里总结了一下leetcode的三道题目，都是使用相似的思路，就是使用单调栈去逐步删除元素。

402. 移掉K位数字

给定一个以字符串表示的非负整数num ，移除这个数中的 k 位数字，使得剩下的数字最小。

注意:

num 的长度小于 10002 且 ≥ k。
num 不会包含任何前导零。

思路：

首先逐个比较，符合条件的放到双向列表里：

    for (int i = 0; i < length; i++) {
        char digit=num.charAt(i);
        while (!dq.isEmpty() && k>0 && dq.peekLast()>digit){
            dq.pollLast();
            k--;
        }
        dq.offerLast(digit);
    }

但是有可能后面的数字元素比较有序，最后还没有删除完，所以第二步：

    for (int i = 0; i < k; i++) {
        dq.pollLast();
    }

最后将双向列表转换为字符串，但是得考虑第一个数字为0的情况：

    while (!dq.isEmpty()){
        Character digit = dq.pollFirst();
        if(leadZero && digit=='0') continue;
        leadZero=false;
        sb.append(digit);
    }

答案

import java.util.Deque;
import java.util.LinkedList;

public class removeKdigits {
    public String removeKdigits(String num, int k) {
        Deque<Character> dq=new LinkedList<>();
        int length=num.length();
        for (int i = 0; i < length; i++) {
            char digit=num.charAt(i);
            while (!dq.isEmpty() && k>0 && dq.peekLast()>digit){
                dq.pollLast();
                k--;
            }
            dq.offerLast(digit);
        }
        // 万一k最后还是不等于0  在这里舍弃最后的k位
        for (int i = 0; i < k; i++) {
            dq.pollLast();
        }
        StringBuilder sb=new StringBuilder();
        boolean leadZero=true;
        // 考虑开始位置是0的情况
        while (!dq.isEmpty()){
            Character digit = dq.pollFirst();
            if(leadZero && digit=='0') continue;
            leadZero=false;
            sb.append(digit);
        }
        return sb.length()==0?"0":sb.toString();
    }
    // 方法2 经过测试 比上述方法还要慢 所以记住方法1为主
    public String removeKdigits2(String num, int k) {
        int len=num.length();
        char[] stack=new char[len-k];
        int top=-1;
        int remain=len-k;
        // 删除k个的情况
        for (int i = 0; i < len; i++) {
            char digit=num.charAt(i);
            while (top>=0 && k>0 && stack[top]>digit){
                top--;
                k--;
            }
            if(top<remain-1){
                stack[++top]=digit;
            }else{
                k--;
            }
        }
        // 数组转换成字符串
        boolean leadZero=true;
        String res=new String();
        for (char c : stack) {
            if(leadZero && c=='0') continue;
            leadZero=false;
            res+=c;
        }
        return res.length()==0?"0":res;
    }
}

上述方法一和方法二的思路一致，就是方法一用的Dequeue 方法二用的数组。

316. 去除重复字母

该题目和上一题差不多 区别仅在于首先创建个数组 标记每个字母出现的次数，并且删除的个数不是固定的k

更新完频次后 后面的做法和上一题没什么区别

import java.util.Deque;
import java.util.LinkedList;

public class removeDuplicateLetters316 {
    public String removeDuplicateLetters(String s) {
        // 首先记录各个字母出现的次数
        Deque<Character> dq=new LinkedList<>();
        int[] charactersFrequency=new int[26];
        char[] chars = s.toCharArray();
        // 更新出现的频次
        for (char c :chars){
            charactersFrequency[c-'a']++;
        }
        int len=chars.length;
        for (char c : chars) {
            if(!dq.contains(c)){
                while (!dq.isEmpty() && dq.peekLast()>c && charactersFrequency[dq.peekLast()-'a']>0){
                    dq.pollLast();
                }
                dq.offerLast(c);
            }
            charactersFrequency[c-'a']--;
        }
        // dq转换为StringBuilder
        StringBuilder sb=new StringBuilder();
        for (Character c : dq) {
            sb.append(c);
        }
        return sb.toString();
    }
}

321. 拼接最大数

在上面两题的基础上变得复杂了些；

思路：

1. 因为最后两个数组留下来的元素数目之和是固定的，是k 。所以需要遍历所有长度的情况
2. 延续上述两题的做法，在某个数组内留下i个数字 即函数maxSubsequence
3. 得到的结果需要按照最大值的形式进行合并，并且不同长度遍历的情况之间也要相互比较大小

import java.util.Deque;
import java.util.LinkedList;

public class maxNumber {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int m=nums1.length,n=nums2.length;
        int[] maxSubsequence=new int[k];
        // 遍历nums1 和 nums2 长度不同的情况
        // nums1 最多k-n个 最多m个
        int start=Math.max(0,k-n),end=Math.min(k,m);
        for (int i=start;i<=end;i++){
            int[] subsequence1=maxSubsequence(nums1,i);
            int[] subsequence2=maxSubsequence(nums2,k-i);
            int[] curMaxSubsequence=merge(subsequence1,subsequence2);
            if(compare(curMaxSubsequence,0,maxSubsequence,0)>0){
                System.arraycopy(curMaxSubsequence,0,maxSubsequence,0,k);
            }
        }
        return maxSubsequence;
    }

    // 某一个数组内部进行 留下k个数据的情况
    public int[] maxSubsequence(int[] nums,int k){
        Deque<Integer> dq=new LinkedList<>();
        int len=nums.length;
        // 通过这个数组的方式 避免了使用Dequeue
        // 但经过测试Dequeue 运行速度快一点
        // 留下k个的情况
        //int[] stack=new int[k];

        int remain=len-k;
        for (int i = 0; i < len; i++) {
            int num = nums[i];
            while (!dq.isEmpty() && dq.peekLast() < num && remain > 0) {
                dq.pollLast();
                remain--;
            }
            dq.offerLast(num);
        }
        // 万一remain最后还没归0
        for (int i = 0; i < remain; i++) {
            dq.pollLast();
        }
        int[] res=new int[k];
        for (int i = 0; i < k; i++) {
            res[i]=dq.pollFirst();
        }
        return res;
    }
    
    public int[] merge(int[] nums1,int[] nums2){
        int len1=nums1.length,len2=nums2.length;
        if(len1==0) return nums2;
        if(len2==0) return nums1;
        int mergeLen=len1+len2;
        int[] mergedNum=new int[mergeLen];
        int index1=0,index2=0;
        for (int i = 0; i < mergeLen; i++) {
            if(compare(nums1,index1,nums2,index2)>0){
                mergedNum[i]=nums1[index1++];
            }
            else{
                mergedNum[i]=nums2[index2++];
            }
        }
        return mergedNum;
    }
    // 注意这边先看最高位大小 之后再看位数长度
    public int compare(int[] nums1,int index1,int[] nums2,int index2){
        int len1=nums1.length,len2=nums2.length;
        while (index1<len1 && index2<len2){
            int difference=nums1[index1]-nums2[index2];
            if(difference!=0){
                return difference;
            }else{
                index1++;
                index2++;
            }
        }
        return (len1-index1)-(len2-index2);

    }

}