滑动窗口+双指针+单调队列+单调栈

双指针的应用

1. 先暴力
2. 考虑是否有单调性
3. 利用单调性优化

例 leetcode 167 两数之和II

如果暴力，就是两重循环。
双指针法

    public int[] twoSum(int[] numbers, int target) {
        int left=0,right=numbers.length-1;
        int []res = new int[2];
        while(left<right){
            if(numbers[left]==target-numbers[right]){
                res[0]=left+1;
                res[1]=right+1;
                return res;
            }else if(numbers[left]<target-numbers[right])
                left++;
            else
                right--;
        }
        return res;
    }

例 leetcode88 合并两个有序数组

双指针比较，注意反向填充可以不覆盖。

    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int size=m+n-1;
        while(size>=0){
            int val1= m>0?nums1[m-1]:Integer.MIN_VALUE;
            int val2= n>0?nums2[n-1]:Integer.MIN_VALUE;
            nums1[size]=Math.max(val1,val2);
            if(val1>=val2)
                m--;
            else 
                n--;
            size--;
        }
    }

例 leetcode 26 删除排序数组中重复项

简单直接的双指针

    int removeDuplicates(vector<int>& nums) {
        int k=1;
        if(nums.size()==0)
            return 0;
        for(int i=1;i<nums.size();i++)
            if(nums[i]!=nums[k-1]){
                nums[k]=nums[i];
                k++;
            }
        return k;
    }

滑动窗口算法

滑动窗口在某种程度来看可以算作一个特殊的双指针算法。

例 leetcode76. 最小覆盖子串

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。
1.暴力的做法：枚举所有子串，是否包含T中所有字母。找到最小的。
2.单调性？在右指针往后走的时候，左指针不会往前走。

    public String minWindow(String s, String t) {
        String res="";
        char[] arrays= s.toCharArray();
        char[]arrayt = t.toCharArray();
        HashMap<Character,Integer> map = new HashMap<>();
        for(char a :arrays) map.put(a,0);
        for(char a :arrayt) map.put(a,0);
        for(char a :arrayt) map.put(a,map.get(a)+1);
        int cnt = t.length();
        for(int i=0,j=0,c=0;i<arrays.length;i++){
            if(map.get(arrays[i])>=1)c++;
            map.put(arrays[i],map.get(arrays[i])-1);
            while(j<arrays.length&&map.get(arrays[j])<0){
                map.put(arrays[j],map.get(arrays[j])+1);
                j++;
            }
            if(c==cnt)
                if(res.equals("")||res.length()>i-j+1)res=s.substring(j,i+1);
        }
        return res;
    }

例 leetcode 32 最长有效括号

括号匹配问题很多都是通过前缀和的考虑方法来设计的
把左括号看做负一，右括号看做1，一个匹配就是所有前缀和大于等于0，且总和等于0的情况。
但是从左到右扫描只能扫描到右括号小于等于左括号的情况，对于（（（）），不会出现等于0的情况，无法统计进去。
所以倒过来再匹配一遍就可以全部统计到。

    int helper(String s){
        int res= 0;
        for(int i=0,start=0,cnt=0;i<s.length();i++){
            if(s.charAt(i)=='(')cnt++;
            else{
                cnt--;
                if(cnt<0){
                    start=i+1;
                    cnt=0;
                }
                else if(cnt==0)
                    res=Math.max(res,i-start+1);
            }
        }
        return res;
    }
    public int longestValidParentheses(String s) {
        int res = helper(s);
        char[] news = new StringBuffer(s).reverse().toString().toCharArray();
        for(int i=0;i<news.length;i++)
            news[i]=(char)(news[i]^(char)(1));
        return Math.max(res,helper(String.valueOf(news)));
    }

单调栈

查找每个数左侧第一个比它小的数。
删除完所有的冗余元素，栈顶就是左侧第一个比它小的数。

例 leetcode 155最小栈

同时维护一个最小栈，不断的求前缀最小值。
最小栈当进栈小于栈顶时进栈，当进栈大于栈顶时再次进栈栈顶元素

class MinStack {
    /** initialize your data structure here. */
    public Stack<Integer> stackMin = new Stack<>();
    public Stack<Integer> stack =    new Stack<>();
    public MinStack() {
    }
    public void push(int x) {
        stack.push(x);
        if(stackMin.empty())
            stackMin.push(x);
        else{
            if(x>=stackMin.peek())
                stackMin.push(stackMin.peek());
            else
                stackMin.push(x);
        }
    }
    public void pop() {
        stack.pop();
        stackMin.pop();
    }
    public int top() {
        return stack.peek();
    }
    public int getMin() {
        return stackMin.peek();
    }
}

例 leetcode 86

例leetcode 42

例 leetcode239

单调队列

单调队列等于滑动窗口的最值

例 leetcode918