单调栈的应用及代码

单调栈

单调递增栈：栈中数据出栈的序列为单调递增序列
单调递减栈：栈中数据出栈的序列为单调递减序列

求最大子矩阵的大小
给定一个整型矩阵map， 其中的值只有0 和 1 两种， 求其中全是1 的所有矩形区域中， 最大的矩形区域为1的数量。

例如：

1 0 1 1

1 1 1 1

1 1 1 0

其中，最大的矩形区域有6个1，所以返回6 。

package cao;

import java.util.Stack;

//滑动窗口
public class hello {
    public static int heightCompute(int[][] arr){
        if(arr==null||arr.length==0||arr[0].length==0)
            return 0;
        int[] height=new int[arr[0].length];//列的长度
        int maxnum=0;
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[0].length;j++)
            {
                height[j]=arr[i][j]==0?0:height[j]+1;
            }
            maxnum=Math.max(maxnumCompute(height),maxnum);
        }
        return maxnum;
    }

    //一个数组表示直方图，求里面最大的那个矩形
    private static int maxnumCompute(int[] height) {
        if(height==null||height.length==0){
            return 0;
        }
        int max=0;//最大面积
        int area=0;//当前面积
        Stack<Integer> stack=new Stack<Integer>();//单调栈，从小到大
        //for循环遍历数组中的每一个数
       for(int i=0;i<height.length;i++) {
            while (!stack.isEmpty() && height[i] <= stack.peek())
            {
                int j=stack.pop();//当前需要计算的值
                int k=stack.isEmpty()?-1:stack.peek();//最左到达位置;当前位置为i,因此最右固定为i
                area=height[i-k-1]*height[j];//当前值的面积
                max=Math.max(max,area);
            }
            stack.push(i);
        }
        //while清算栈中剩余元素
        while(!stack.empty()){
            int R=height.length;
            int L=stack.isEmpty()?-1:stack.peek();
            area=(R-L-1)*height[stack.pop()];
            max=Math.max(max,area);
        }
        return max;
    }

    public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 0, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 0}};
        System.out.println(heightCompute(arr));
    }
}

结果：6

可见山峰对问题
一个数组代表一个环形的山，每个元素都代表一座山，每个座山上可以放烽火。
两座山峰相互看见的前提：

1.相邻的山必能相互看见烽火
2.如果不相邻的两座山峰，只要存在一条路，这条路上的任意一个值都不大于路两头的山峰中较小值，就认为他们两座山可以相互看见

package cao;
import java.util.Stack;
public class hello {
    public static void main(String[] args)
    {
        int[] arr=new int[5];
        arr= new int[]{2, 6, 3, 5, 6};
        System.out.println(conmunication(arr));
    }

    //定义值和次数
    public static class pair{
        public int value;
        public int times;
        public pair(int value){
            this.value=value;
            this.times=1;
        }
    }
    //一个圈中找下一个位置
    public static int nextindex(int size,int i){
        return i<(size-1)?(i+1):0;
    }
    //相同数值之间可以看到对方，次数为Cn2(排列组合)
    public static long interconmunication(int times) {
        return times==1L?0L:(long)times*(long)(times-1)/2L;
    }
    //利用单调栈进行统计
    public static long conmunication(int[] arr){
        if(arr==null||arr.length<2) return 0;
        int size=arr.length;
        int maxindex=0;
        for(int i=0;i<size;i++){
            maxindex=arr[maxindex]<arr[i]?i:maxindex;
        }
        Stack<pair> stack=new Stack<pair>();
        int value=arr[maxindex];
        stack.push(new pair(value));
        int cur=nextindex(size,maxindex);
        long ress=0L;//计算总的可见山峰树
        while(cur!=maxindex){
            int curvalue=arr[cur];
            while(!stack.isEmpty()&&stack.peek().value<curvalue){
                int times=stack.pop().times;
                //次数为cn2+2*n(互相之间可以看见，并且都可以看见两侧)
                ress+=interconmunication(times);
                ress+=2*times;
            }
            //相等时加入已有，次数加1
            if(!stack.isEmpty()&&stack.peek().value==curvalue){
                stack.peek().times++;
            }else{
                //加入一个新的元素
                stack.push(new pair(curvalue));
            }
            cur=nextindex(size,cur);
        }
        //清空栈
        while(!stack.isEmpty()){
            int times=stack.pop().times;
            ress+=interconmunication(times);
            if(!stack.isEmpty()){
                ress+=times;
                //栈底只有一个元素时，倒数第二个按照倒数第一个元素的个数是否为1分情况
                if(stack.size()>1){
                    //倒数第一个元素的个数大于1，2*n
                    ress+=times;
                }else{
                    //倒数第一个元素的个数等于1，n
                    ress+=stack.peek().times>1?times:0;
                }
            }

        }
        return ress;
    }
}

结果：7
321. 拼接最大数
给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。

求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。

class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int m = nums1.length, n = nums2.length;
        //最终答案
        int[] maxSubsequence = new int[k];
        //nums1最少个数-最多个数
        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;
    }
    //单调栈从nums数组获得包含k个元素的子序列
    public int[] maxSubsequence(int[] nums, int k) {
        int length = nums.length;
        int[] stack = new int[k];
        //下标
        int top = -1;

        //可以剔除的元素个数的元素个数
        int remain = length - k;
        for (int i = 0; i < length; i++) {
            int num = nums[i];
            //栈中有元素并且栈顶小于当前元素并且还可以剔除元素(remain控制是否还可以删除栈中元素)
            while (top >= 0 && stack[top] < num && remain > 0) {
                top--;
                remain--;
            }
            //栈中元素还没到k个
            if (top < k - 1) {
                stack[++top] = num;
            } else {
                //栈中元素已经有k个了
                remain--;
            }
        }
        return stack;
    }

    public int[] merge(int[] subsequence1, int[] subsequence2) {
        int x = subsequence1.length, y = subsequence2.length;
        if (x == 0) {
            return subsequence2;
        }
        if (y == 0) {
            return subsequence1;
        }
        int mergeLength = x + y;
        int[] merged = new int[mergeLength];
        int index1 = 0, index2 = 0;
        for (int i = 0; i < mergeLength; i++) {
            if (compare(subsequence1, index1, subsequence2, index2) > 0) {
                merged[i] = subsequence1[index1++];
            } else {
                merged[i] = subsequence2[index2++];
            }
        }
        return merged;
    }

    public int compare(int[] subsequence1, int index1, int[] subsequence2, int index2) {
        int x = subsequence1.length, y = subsequence2.length;
        while (index1 < x && index2 < y) {
            //比较当前两个元素
            int difference = subsequence1[index1] - subsequence2[index2];
            //两个数字不同直接返回差
            if (difference != 0) {
                return difference;
            }
            //否则比较下个位置，直至不同
            index1++;
            index2++;
        }
        //先遍历完的数组小
        return (x - index1) - (y - index2);
    }
}