05、所有子数组中最大值问题

//暴力解法如下：
public static int max1(int[] arr) {
    int max = Integer.MIN_VALUE;//代表所有字数组中，最大值（累加和 * 子数组最小值）是多少
    for (int i = 0; i < arr.length; i++) {
        for (int j = i; j < arr.length; j++) {
            int minNum = Integer.MAX_VALUE;
            int sum = 0;//表示子数组的累加和
            for (int k = i; k <= j; k++) {
                sum += arr[k];
                minNum = Math.min(minNum, arr[k]);
            }
            max = Math.max(max, minNum * sum);
        }
    }
    return max;
}

解题思路如下（以某一个位置为基准，向左或向右扩，直到比其小，就停止）：

1、以0位置的3为最小值的最大子数组是多少，可以看到是3、4、5、6、3

2、以1位置的4为最小值的最大子数组是多少，可以看到是4、5、6

3、以2位置的5为最小值的最大子数组是多少，可以看到是5、6

4、以3位置的6为最小值的最大子数组是多少，可以看到是6

5、以4位置的3为最小值的最大子数组是多少，可以看到是3、4、5、6、3

6、以5位置的2为最小值的最大子数组是多少，可以看到是3、4、5、6、3、2

7、以6位置的7为最小值的最大子数组是多少，可以看到是7

最终的结果一定是其中的一个。

可以看到这不就是单调栈问题吗？

 

/**
 * 利用单调栈解法如下：
 * int[] arr = {2, 3, 4, 1, 2};
 * 解析：
 * 当i=0的时候，stack={0}
 * 当i=1的时候，stack={0,1}
 * 当i=2的时候，stack={0,1,2}
 * 当i=3的时候，stack={0,1,2}
 *     此时需要弹出数据了，弹出2位置的4，以2位置的4最小值，求结果（4）
 *     弹出1位置的3，以1位置的3最小值，求结果（3，4）
 *     弹出0位置的2，以0位置的2最小值，求结果（2，,3，,4）
 *     此时栈为空了，再把3位置的1压入
 * 当i=4的时候，stack={3,4}
 * 后面过程省略......
 * @param arr
 * @return
 */
public static int max2(int[] arr) {
    int size = arr.length;
    int[] sums = new int[size];//存放0到各个位置的累加和
    sums[0] = arr[0];
    for (int i = 1; i < size; i++) {
        sums[i] = sums[i - 1] + arr[i];
    }
    int max = Integer.MIN_VALUE;
    //栈里面元素满足：从小到大
    Stack<Integer> stack = new Stack<Integer>();
    for (int i = 0; i < size; i++) {
        //求解以i为最小值的子数组
        while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) {
            int j = stack.pop();//弹出栈中最后一个元素
            //如果stack.isEmpty()为空的时候，那么sums[i - 1] 表示以i为结尾的子数组的累加和
            //sums[i - 1] - sums[stack.peek()] 表示以i为结尾的子数组的累加和
            //stack.peek() 栈中最后一个元素值是多少
            //arr[j] 代表子数组中最小的值
            int sum = (stack.isEmpty() ? sums[i - 1] : (sums[i - 1] - sums[stack.peek()]));
            max = Math.max(max, sum * arr[j]);
        }
        stack.push(i);
    }
    while (!stack.isEmpty()) {
        int j = stack.pop();
        int sum = (stack.isEmpty() ? sums[size - 1] : (sums[size - 1] - sums[stack.peek()]));
        max = Math.max(max, sum * arr[j]);
    }
    return max;
}