LeetCode 刷题记录 42. Trapping Rain Water

最新推荐文章于 2022-05-18 22:16:56 发布
最新推荐文章于 2022-05-18 22:16:56 发布
阅读量95 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dldldl1994/article/details/100940033
版权

题目：
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
在这里插入图片描述
The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
解法1：暴力法
核心思想是以列为单位求储存的水
对于每一列，首先求它左边最高列和右边最高列，然后取其中较小值，然后与当前列比较，如果大于当前列才能储水，储水的量为其差值
对于图中来说：
在这里插入图片描述
第1列：不能储水
第2列：当前列: 1 左边最高列 : 0 右边最高列:3,较小值：0，小于当前列不能储水
第3列：当前列: 0 左边最高列 : 1 右边最高列:3,较小值：1，大于当前列，储水1-0=1
第4列：当前列: 2 左边最高列 : 1 右边最高列:3,较小值：1，小于当前列不能储水
第5列：当前列: 1 左边最高列 : 2 右边最高列:3,较小值：2，大于当前列，储水2-1=1
暴力法遍历每一列，然后找到左边最高和右边最高
c++：

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int sum = 0;
        for(int i = 1; i < (n - 1); i++){
            int maxLeft = 0;
            for(int j = (i - 1); j >= 0; j--){
                if(height[j] > maxLeft){
                    maxLeft = height[j];
                }
            }
            int maxRight = 0;
            for(int j = (i + 1); j < n; j++){
                if(height[j] > maxRight){
                    maxRight = height[j];
                }
            }
            int minRes = min(maxLeft, maxRight);
            if(minRes > height[i]){
                sum += (minRes - height[i]);
            }
        }
        return sum;
    }
};

解法2：对解法1的优化(动态规划）
解法1花费的时间是一个一个找左边最大和右边最大
我们可以用两个数组通过一遍就能得到所有位置的左边最大高度和右边最大高度
maxLeft[i]代表，i左边的最大高度（不包括i）
maxRight[i]代表，i右边的最大高度（不包括i）
核心代码，首先0的左边的最大高度为0不用计算，n-1的右边的最大高度为0不用计算
从1开始到n-1
maxLeft[i]的值为maxLeft[i-1]和height[i-1]的最大值，如maxLeft[3]的值是maxLeft[3]的值和height[2]的最大值，每递推一次，就更新一下最大值，类似于动态规划
同时更新maxRight[i]，从n-2开始到0

 for(int i = 1; i < n; i++){
            maxLeft[i] = max(maxLeft[i-1],height[i-1]);
            maxRight[n-1-i] = max(maxRight[n-i],height[n-i]);
        }

c++：
首先要特判0，maxLeft[n]，n为0会出错
另外数组要初始化为0

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if(n==0) return 0;
        int sum = 0;
        int maxLeft[n] ={0};
        
        int maxRight[n] = {0};
        
        for(int i = 1; i < n; i++){
            maxLeft[i] = max(maxLeft[i-1],height[i-1]);
            maxRight[n-1-i] = max(maxRight[n-i],height[n-i]);
        }
        for(int i = 1; i < (n - 1); i++){
            
            int minRes = min(maxLeft[i], maxRight[i]);
            if(minRes > height[i]){
                sum += (minRes - height[i]);
            }
        }
        return sum;
    }
};

java：
java不用判0，另外自动初始化为0

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        //if(n==0) return 0;
        int sum = 0;
        int[] maxLeft = new int[n];
        int[] maxRight = new int[n];
        
        for(int i = 1; i < n; i++){
            maxLeft[i] = Math.max(maxLeft[i-1],height[i-1]);
            maxRight[n-1-i] = Math.max(maxRight[n-i],height[n-i]);
        }
        for(int i = 1; i < (n - 1); i++){
            
            int minRes = Math.min(maxLeft[i], maxRight[i]);
            if(minRes > height[i]){
                sum += (minRes - height[i]);
            }
        }
        return sum;
    
    }
}

python：

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        n = len(height)
        
        sum = 0
        maxLeft = [0] * n
        
        maxRight = [0] * n
        
        for i in xrange(1,n):
            maxLeft[i] = max(maxLeft[i-1],height[i-1])
            maxRight[n-1-i] = max(maxRight[n-i],height[n-i])
        
        for i in xrange(1,n-1):
            
            minRes = min(maxLeft[i], maxRight[i])
            if minRes > height[i]:
                sum += (minRes - height[i])
            
        
        return sum;

解法3：
上面的方法都要求左边最高的列和右边最高的列，然后再取其中最小的列与当前列比较
可以换一种思路：
首先我们先找到最高的列，它将数组一分为2，左边的只用考虑左边最高的列，因为右边最高的列为最高的列，且一定会比左边最高的列高
同理右边的只用考虑右边最高的列，因为左边最高的列为最高的列，且一定会比右边最高的列高
然后我们左半边从左到右遍历，如果比当前列高，更新左边最高的列，否则说明左边最高的列比当前列高，更新water
右半边从右到左遍历，如果比当前列高，更新右边最高的列，否则说明右边最高的列比当前列高，更新water
c++：

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int sum = 0;
        int max = 0;
        for(int i = 0; i < n; i++){
            if(height[i] > height[max]){
                max = i;
            }
        }
        int peak = 0;
        for(int i = 0; i < max; i++){
            
            if(height[i] > peak){
                peak = height[i];
            } else {
                sum += (peak - height[i]);
            }
            
        }
        int top = 0;
        for(int i = (n-1); i > max; i--){
            
            if(height[i] > top){
                top = height[i];
            } else {
                sum += (top - height[i]);
            }
            
        }
        return sum;
    }
};

java：

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int sum = 0;
        int max = 0;
        for(int i = 0; i < n; i++){
            if(height[i] > height[max]){
                max = i;
            }
        }
        int peak = 0;
        for(int i = 0; i < max; i++){
            
            if(height[i] > peak){
                peak = height[i];
            } else {
                sum += (peak - height[i]);
            }
            
        }
        int top = 0;
        for(int i = (n-1); i > max; i--){
            
            if(height[i] > top){
                top = height[i];
            } else {
                sum += (top - height[i]);
            }
            
        }
        return sum;
    
    }
}

python：

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        n = len(height)
        
        sum, maxidx = 0, 0
        
        
        for i in xrange(n):
            if height[i] > height[maxidx]:
                maxidx = i
            
        
        peak = 0
        for i in xrange(maxidx):
            
            if height[i] > peak:
                peak = height[i]
            else:
                sum += (peak - height[i])
            
            
        
        top = 0
        for  i in xrange((n-1),maxidx,-1):
            
            if height[i] > top:
                top = height[i]
            else:
                sum += (top - height[i])
            
            
        
        return sum;

解法4：
用栈解决，如果栈为空，或者当前的高度小于等于栈顶的高度，说明此时没有积水，将坐标压进栈，用坐标而不是高度，是方便计算计算积水的宽
在这里插入图片描述
当我们一旦发现当前的列大于栈顶，此时说明有坑存在，此时我们要计算积水，
计算积水，需要栈顶的列，和左右两堵墙，取左右两堵墙的最小者，然后与栈顶的高度相减即为积水的高度，然后在乘以宽度即为积水的量，为1
在这里插入图片描述
原有的列出栈，继续计算，此时积水为2
在这里插入图片描述
注意有一种情况，没有左面的墙，不能计算积水
在这里插入图片描述
c++

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int sum = 0;
        stack<int> st;
        int i = 0;
        while(i < n){
            if(st.empty() || height[i] <= height[st.top()]){
                st.push(i++);
            } else {
                int t = st.top();
                st.pop();
                if(st.empty()) continue;
                sum += (min(height[i], height[st.top()]) - height[t]) * (i - st.top() - 1);
            }
        }
            
        
        return sum;
    }
};

java：

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int sum = 0;
        Stack<Integer> st = new Stack<>();
        int i = 0;
        while(i < n){
            if(st.empty() || height[i] <= height[st.peek()]){
                st.push(i++);
            } else {
                int t = st.peek();
                st.pop();
                if(st.empty()) continue;
                sum += (Math.min(height[i], height[st.peek()]) - height[t]) * (i - st.peek() - 1);
            }
        }
            
        
        return sum;
    
    }
}

python：

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        n = len(height)
        sum = 0
        st = []
        i = 0
        while i < n:
            if not len(st) or height[i] <= height[st[-1]]:
                st.append(i)
                i += 1
            else:
                
                t = st.pop()
                if len(st) == 0: continue
                print str(min(height[i], height[st[-1]])) + " " + str(height[t]) + " " + str(i - st[-1] - 1)
                sum += (min(height[i], height[st[-1]]) - height[t]) * (i - st[-1] - 1);
            
        return sum
dldldl1994
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode--------接雨水python
newica的博客
04-04 325
题目不重述了。 小菜一枚，思路还是比较欠缺，按照leetcode题解的精选，用python写了一下。加深理解吧。 按行接雨水： 思路：首先寻找数组的最大值，即最多一共有几行。然后分别求每一行的雨水量。 从第一行开始，第一种情况是遇到比第一行低的块，可以存到一方水；第二种情况是遇到和第一行一样高或者比第一行要高的块，重新开始计算雨水量。 直到最高行，雨水量计算完毕。思路比较清晰，可以看...
LeetCode42-接雨水
飞奔的菜猪的博客
12-22 263
今天是冬至日，也是考研第一天 考完试，大家也要记得吃饺子啊！ 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。 示例: 输入: [0,1,0,2,1,0,1...
LeetCode题解(面试17.21)：直方图的水量(Python)
长行
11-19 249
题目：原题链接（困难） 标签：栈、数组、双指针 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N)O(N)O(N) O(N)O(N)O(N) 48ms (67.27%) Ans 2 (Python) Ans 3 (Python) 解法一（双向遍历）： class Solution: def trap(self, height: List[int]) -> int: size = len(height)
42. 接雨水---双指针
小小核桃
06-27 559
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 上面是由数组 [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 思路： 一个简单的思路就是...
python每日一题（11.26）
ly_twt的博客
11-26 425
1、如何从列表中随机抽取一个元素？ from random import choice list1 = [1, 2, 3, 4, 5, 6, 7, 8] print(choice(list1)) 2、如何从列表中随机抽取若干个元素（无重复）？ 法一： from random import sample list1 = [1, 2, 3, 4] print(sample(list1...
leetcode不会-3D-Trapping-Rain-Water-System:该repo包含复杂3D雨水收集系统的解决方案，该系统在Lee
06-30
leetcode 不会3D 捕集雨水系统 该 repo 包含复杂 3D 雨水收集系统的解决方案，该系统在 Leetcode Problem No. 407 和 Google Interview Round 中提出。 此外，它将“0”视为系统的排水。 （查看自述文件以获得详细...
leetcode答案-leetcode:leetcode.com问题的答案
06-30
leetcode 答案leetcode leetcode.com 问题的答案 跑步 python -m venv .venv source .venv/bin/activate pip install -r requirements.txt pytest <question>/tests.py ...lc42_trapping_rain_water/tests.py
C语言入门-leetcode练习之第42题接雨水.zip
最新发布
05-26
接下来，我们转向LeetCode的第42题“接雨水”（Trapping Rain Water）。这是一道典型的二维数组问题，考察的是动态规划和双指针技巧。 题目描述：给定一个高度不一的数组代表地面，雨水会积累在低点。求能容纳的...
python-leetcode面试题解之第42题接雨水-题解.zip
03-19
在本压缩包中，我们关注的是一个Python编程相关的学习资源，特别针对LeetCode平台上的第42题“接雨水”（Trapping Rain Water）的面试题解。LeetCode是一个广泛被程序员用来提升算法技能和准备面试的在线平台，其中...
leetcode1004-leetcode:leetcode删号重练个人记录:)
07-01
leetcode 1004 leetcode NEXT：42 Trapping Rain Water 刷题顺序 刷题内容总的来说包括数据结构、算法和...刷题记录 Array (20/20) Hash Table (20/20) Linked List(20/20) Two Pointers(12/20) 42 Trapping Rain Water
力扣题解系列：42：接雨水
qq_38813052的博客
06-12 1693
题目：42. 接雨水 题目描述： 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。 来源：https://leetcode-cn.com/problems/trapping-rain-water/ 示例： 输入: [0,1,0,2,1,0,1,3,2,1,2,1] 输出: 6 思路
leetcode题解python版：41-45
baidu_41689104的博客
08-02 233
41、 缺失的第一个正数 给你一个未排序的整数数组，请你找出其中没有出现的最小的正整数。 解：先排序，然后从第一个大于零的数nums[i]开始往前走，如果它大于1，就返回一，否则不断+1，如果后面的数是前面的+1或+0，继续，否则输出前面的数+1即可。 class Solution: def firstMissingPositive(self, nums: List[int]) -> int: if not nums: return 1
接雨水 四种解法（Python）
You can either travel or read,but either your body or soul must be on the way.
05-18 1363
单调栈 时间复杂度O(N) class Solution: def trap(self, height: List[int]) -> int: indexStack = [] sum = 0 for i in range(len(height)): while indexStack and height[i] > height[indexStack[-1]]: bottom = in
42. 接雨水
zjbzwhwhz的博客
07-27 144
class Solution: def trap(self, height: List[int]) -> int: # 边界条件 if not height: return 0 n = len(height) left,right = 0, n - 1 # 分别位于输入数组的两端 maxleft,maxright = height[0],height[n - 1] ans = 0 ...
力扣42.接雨水-python解法总结
pythonuser1的博客
09-07 921
解法一：暴力无脑解题法（超时） 对每一个格子进行推算，根据左右最高的格子数来计算能接水的单位数，最后逐一相加 class Solution: def trap(self, height: List[int]) -> int: ans = 0 for i in range(len(height)): max_left, max_right = 0,0 # 寻找 max_left for j......
接雨水 双指针
人工智能曾小健
09-16 106
class Solution: def trap(self, height: List[int]) -> int: ans = 0 left, right = 0, len(height) - 1 leftMax = rightMax = 0 while left < right: leftMax = max(leftMax, height[left]) ...
LeetCode 刷题记录 7. Reverse Integer
dldldl1994的博客
04-16 4890
Given a 32-bit signed integer, reverse digits of an integer. Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321 Example 3: Input: 120 Output: 21 Note: Assume we are dealing with an ...
LeetCode 刷题记录 8. String to Integer (atoi)
dldldl1994的博客
04-18 430
Implement atoi which converts a string to an integer. The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this...
LeetCode 刷题记录 95. Unique Binary Search Trees II
dldldl1994的博客
01-13 254
题目： Given an integer n, generate all structurally unique BST’s (binary search trees) that store values 1 … n. Example: Input: 3 Output: [ [1,null,3,2], [3,2,null,1], [3,1,null,null,2], [2,1,3], [1,nul...
leetcode刷题记录，包含代码和思路讲解，非常详细
07-28
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值