当青训营遇上码上掘金

主题：攒青豆

现有 n 个宽度为 1 的柱子，给出 n 个非负整数依次表示柱子的高度，排列后如下图所示，此时均匀从上空向下撒青豆，计算按此排列的柱子能接住多少青豆。（不考虑边角堆积）

以下为上图例子的解析：

输入：height = [5,0,2,1,4,0,1,0,3]  
输出：17  
解析：上面是由数组 [5,0,2,1,4,0,1,0,3] 表示的柱子高度，在这种情况下，可以接 17 个单位的青豆。

解法分析

这是一道十分经典的算法题，又名“接雨水”。

解法一：暴力解法

暴力解法就是求每一列能够接下的青豆数，然后逐列相加。针对每一列，遍历找到其左边最高的列和右边最高的列，它能够攒下的青豆数就是两个高列中较小值与它本身高度的差值。
具体代码求解如下：

  public static int trap_1(int[] height) {
        int sum = 0;
        //最两端的列不用考虑，因为一定不会有青豆。所以下标从 1 到 length - 2
        for (int i = 1; i < height.length - 1; i++) {
            int max_left = 0;
            //找出左边最高
            for (int j = i - 1; j >= 0; j--) {
                if (height[j] > max_left) {
                    max_left = height[j];
                }
            }
            int max_right = 0;
            //找出右边最高
            for (int j = i + 1; j < height.length; j++) {
                if (height[j] > max_right) {
                    max_right = height[j];
                }
            }
            //找出两端较小的
            int min = Math.min(max_left, max_right);
            //只有较小的一段大于当前列的高度才会有青豆，其他情况不会有青豆
            if (min > height[i]) {
                sum = sum + (min - height[i]);
            }
        }
        return sum;
    }

暴力解法的时间复杂度为O(n²),空间复杂度为O(1)。

解法二：动态规划

针对暴力解法分析，我们发现，每一次求左右最高列时都要将所有列遍历一遍，是O(n)复杂度，导致时间复杂度很高。优化一下，可以用两个数组进行存储，max_left [i] 代表第 i 列左边最高的墙的高度，max_right[i] 代表第 i 列右边最高的墙的高度。（注意这里的第 i 列左（右）边最高的墙不包括自身）

具体代码求解如下：

    public static int trap_2(int[] height) {
        int sum = 0;
        int[] max_left = new int[height.length];
        int[] max_right = new int[height.length];

        for (int i = 1; i < height.length - 1; i++) {
            max_left[i] = Math.max(max_left[i - 1], height[i - 1]);
        }
        for (int i = height.length - 2; i >= 0; i--) {
            max_right[i] = Math.max(max_right[i + 1], height[i + 1]);
        }
        for (int i = 1; i < height.length - 1; i++) {
            int min = Math.min(max_left[i], max_right[i]);
            if (min > height[i]) {
                sum = sum + (min - height[i]);
            }
        }
        return sum;
    }

时间复杂度：O(n)，空间复杂度：O(n)(用来保存每一列左边最高的墙和右边最高的墙)。

解法三：单调栈

类似括号匹配，我们使用栈来进行墙的匹配，每次匹配出一对墙，就计算这两堵墙之间的青豆数。

我们用栈保存每堵墙。当遍历墙的高度的时候，如果当前高度小于栈顶的墙高度，说明这里会有积水，我们将墙的高度的下标入栈。如果当前高度大于栈顶的墙的高度，说明之前的积水到这里停下，我们可以计算下有多少积水了。计算完，就把当前的墙继续入栈，作为新的积水的墙。

具体代码求解如下：

  public static int trap_3(int[] height) {
        int sum = 0;
        Stack<Integer> stack = new Stack<>();
        int current = 0;
        while (current < height.length) {
            //如果栈不空并且当前指向的高度大于栈顶高度就一直循环
            while (!stack.empty() && height[current] > height[stack.peek()]) {
                int h = height[stack.peek()]; //取出要出栈的元素
                stack.pop(); //出栈
                if (stack.empty()) { // 栈空就出去
                    break;
                }
                int distance = current - stack.peek() - 1; //两堵墙之前的距离。
                int min = Math.min(height[stack.peek()], height[current]);
                sum = sum + distance * (min - h);
            }
            stack.push(current); //当前指向的墙入栈
            current++; //指针后移
        }
        return sum;
    }

时间复杂度：O(n)，空间复杂度：O(n)。

文章完整代码

已发布于码上掘金

当青训营遇上码上掘金之攒青豆