[Leedcode][JAVA][第42题][动态规划][双指针][栈]

最新推荐文章于 2022-03-17 23:46:37 发布

CryptWinter

最新推荐文章于 2022-03-17 23:46:37 发布

阅读量293

点赞数

分类专栏：非0即1 刷题文章标签： leetcode java 动态规划

原文链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

版权

刷题同时被 2 个专栏收录

249 篇文章 2 订阅

订阅专栏

非0即1

239 篇文章 1 订阅

订阅专栏

【问题描述】

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

![image.png](https://upload-images.jianshu.io/upload_images/17025746-87f6db1a993ce416.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

【解答思路】

1. 栈 ->括号匹配

1.当前高度小于等于栈顶高度，入栈，指针后移。

2.当前高度大于栈顶高度，出栈，计算出当前墙和栈顶的墙之间水的多少，然后计算当前的高度和新栈的高度的关系，重复第 2 步。直到当前墙的高度不大于栈顶高度或者栈空，然后把当前墙入栈，指针后移。

3.水量：(Min ( max _ left ，max _ right ) - height [ i ] ) *两个墙之间的距离
时间复杂度：O(N) 空间复杂度：O(N)

public int trap6(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;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

2. 按列暴力

时间复杂度：O(N^2) 空间复杂度：O(1)
求每一列的水，关注当前列，以及左边最高的墙，右边最高的墙就够了。
装水的多少，当然根据木桶效应，需要看左边最高的墙和右边最高的墙中较矮的一个就够了
三种情况：

较矮的墙的高度大于当前列的墙的高度左边的墙的高度-减去当前列的高度
较矮的墙的高度小于当前列的墙的高度无水
较矮的墙的高度等于当前列的墙的高度无水

public int trap(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;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

3. 动态规划

优化 “对于每一列，我们求它左边最高的墙和右边最高的墙，都是重新遍历一遍所有高度”
max_left [i] 代表第 i 列左边最高的墙的高度，max_right[i] 代表第 i 列右边最高的墙的高度。

时间复杂度：O(N) 空间复杂度：O(N)

public int trap(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;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

优化左右数组->左数组

public int trap(int[] height) {
    int sum = 0;
    int max_left = 0;
    int[] max_right = new int[height.length];
    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++) {
        max_left = Math.max(max_left, height[i - 1]);
        int min = Math.min(max_left, max_right[i]);
        if (min > height[i]) {
            sum = sum + (min - height[i]);
        }
    }
    return sum;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

4. 动态规划双指针优化

（因为第一个柱子和最后一个柱子肯定不能装水，因为不作为装水柱子，而是作为左边最高柱子和右边最高柱子）
时间复杂度：O(N) 空间复杂度：O(1)

使用双指针（左右两边各一个指针）

        我们使用一根一根柱子计算装水量的方法

        left 表示左边当前遍历的柱子（即左边我们需要计算能够装多少水的柱子）
        left_max 表示 left 的左边最高的柱子长度（不包括 left）
        right 表示右边当前遍历的柱子
        right_max 表示 right 的右边最高的柱子长度（不包括 right）

        我们有以下几个公式：            
        当 left_max < right_max 的话，那么我们就判断 left_max 是否比 left 高
            因为根据木桶效应，一个桶装水量取决于最短的那个木板，这里也一样，柱子能否装水取决于左右两边的是否都存在比它高的柱子
            因为 left_max < right_max 了，那么我们只需要比较 left_max 即可
                如果 left_max > left，那么装水量就是 left_max - left
                如果 left_max <= left，那么装水量为 0，即 left 装不了水
        当 left_max >= right_max 的话，同理如上，比较 right_max 和 right

        ？？？？ 为什么 right_max 和 left 隔这么远我们还可以使用 right_max 来判断？
        前提：left_max < right_max
        right_max 虽然跟 left 离得远，但有如下两种情况：
        1、left 柱子和 right_max 柱子之间，没有比 right_max 柱子更高的柱子了，
        那么情况如下：  left 能否装水取决于 left_max 柱子是否比 left 高
                        |
            |           |
            |   |       |
            ↑   ↑       ↑
           l_m  l      r_m

        2、left 柱子和 right_max 柱子之间存在比 right_max 柱子更高的柱子
        那么情况如下：因为存在了比 right_max 更高的柱子，那么我们仍然只需要判断 left_max 是否比 left 高，因为右边已经存在比 left 高的柱子
                    |
                    |   |
            |       |   |
            |   |   |   |
            ↑   ↑   ↑   ↑
           l_m  l  mid  r_m

        初始化指针：
        left = 1;
        right = len - 2;
        left_max = 0;
        right_max = len - 1;
        （因为第一个柱子和最后一个柱子肯定不能装水，因为不作为装水柱子，而是作为左边最高柱子和右边最高柱子）

public int trap(int[] height) {
    int sum = 0;
    int max_left = 0;
    int max_right = 0;
    int left = 1;
    int right = height.length - 2; // 加右指针进去
    for (int i = 1; i < height.length - 1; i++) {
        //从左到右更
        if (height[left - 1] < height[right + 1]) {
            max_left = Math.max(max_left, height[left - 1]);
            int min = max_left;
            if (min > height[left]) {
                sum = sum + (min - height[left]);
            }
            left++;
        //从右到左更
        } else {
            max_right = Math.max(max_right, height[right + 1]);
            int min = max_right;
            if (min > height[right]) {
                sum = sum + (min - height[right]);
            }
            right--;
        }
    }
    return sum;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

5. 逐行分析超时

时间复杂度：O(N^2) 空间复杂度：O(1)

public int trap(int[] height) {
    int sum = 0;
    int max = getMax(height);//找到最大的高度，以便遍历。
    for (int i = 1; i <= max; i++) {
        boolean isStart = false; //标记是否开始更新 temp
        int temp_sum = 0;
        for (int j = 0; j < height.length; j++) {
            if (isStart && height[j] < i) {
                temp_sum++;
            }
            if (height[j] >= i) {
                sum = sum + temp_sum;
                temp_sum = 0;
                isStart = true;
            }
        }
    }
    return sum;
}
private int getMax(int[] height) {
		int max = 0;
		for (int i = 0; i < height.length; i++) {
			if (height[i] > max) {
				max = height[i];
			}
		}
		return max;
}

作者：windliang
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/

【总结】

动态规划，空间换时间，双指针是个好工具
-链表题目也可以使用

2.栈->类比括号匹配

当是数组入栈时，入栈下标，数组的值可以通过下标获得

横纵思考多思考几步想清楚所有情况再动手！！！

CryptWinter

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Leedcode][JAVA][第42题][动态规划][双指针][栈]

【问题描述】给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。![image.png](https://upload-images.jianshu.io/upload_images/17025746-87f6db1a993ce416.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1...
复制链接

扫一扫