LeetCode Top 100 Liked Questions 42. Trapping Rain Water (Java版； Hard)

最新推荐文章于 2024-10-14 00:00:00 发布
最新推荐文章于 2024-10-14 00:00:00 发布
阅读量117 收藏
点赞数
文章标签： LeetCode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlehaes/article/details/100602476
版权

welcome to my blog

LeetCode Top 100 Liked Questions 42. Trapping Rain Water (Java版; Hard)

题目描述
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!

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Example:


class Solution {
    public int trap(int[] height) {
        int n = height.length;
        if(n<=2){
            return 0;
        }
        int Lmax=height[0], Rmax=height[n-1];
        int left = 1, right = n-2;
        int res=0;
        //注意理解这个循环条件
        while(left<=right){
            if(Lmax<Rmax){
                if(Lmax-height[left]>0){
                    res += Lmax-height[left];
                }
                Lmax = Math.max(Lmax, height[left]);
                left++;
            }else{
                if(Rmax-height[right]>0){
                    res += Rmax-height[right];
                }
                Rmax = Math.max(Rmax, height[right]);
                right--;
            }
        }
        return res;
    }
}
第二次做; 除了相向而行的双指针外, 还得用两个变量记录双指针外侧的最大值; 理解height[leftMaxIndex] == height[rightMaxIndex]时,从哪边遍历都行, 比如看看例子[3,0,2,2,3]
/*
双指针, 将N^2的搜索空间降低为N
舍弃高柱子中更矮的柱子
*/
class Solution {
    public int trap(int[] height) {
        int n = height.length;
        //双指针, 从两端向中间
        int left=0, right=n-1;
        //leftMaxIndex表示[0,left]范围上最大值对应的索引;
        //rightMaxIndex表示[right,n-1]范围上最大值对应的索引
        int leftMaxIndex=0, rightMaxIndex=n-1;
        int res = 0;
        while(left<=right){
            int leftMax = height[leftMaxIndex];
            int rightMax = height[rightMaxIndex];
            //左边的高柱子更矮, 移动左指针
            if(leftMax < rightMax){
                //只需要保证leftMax>height[left]就能存水, 因为右边的高柱子更高
                if(leftMax > height[left]){
                    res += leftMax - height[left];
                }
                //不能存水的话说明当前柱子比左侧的高柱子更高, 更新左侧高柱子的索引
                else{
                    leftMaxIndex = left;
                }
                //update
                left++;
            }
            //右边的高柱子更矮, 或者右边的高柱子和左边的高柱子一样高, 此时移动谁都可以
            else{
                if(rightMax > height[right]){
                    res += rightMax - height[right];
                }
                else{
                    rightMaxIndex = right;
                }
                right--;
            }
        }
        return res;
    }
}
第二次做; 一列一列地计算, 先用哈希表记录每一列左右两侧的最大值
//一列一列地计算; 计算之前先统计每一列左右两边的最大值; 只有当前列的高度小于它左右两侧最大值中的较小的那个才能存住水
class Solution {
    public int trap(int[] height) {
        //保存每个数左侧的最大值
        HashMap<Integer, Integer> leftMax = new HashMap<>();
        //保存每个数右侧的最大值
        HashMap<Integer, Integer> rightMax = new HashMap<>();
        int n = height.length;
        // leftMax.put(0,0);
        int max = 0;
        for(int i=1; i<n; i++){
            if(height[i-1] > max)
                max = height[i-1];
            leftMax.put(i, max);
        }
        
        // rightMax.put(n-1, 0);
        max = 0;
        for(int i=n-2; i>=0; i--){
            if(height[i+1]>max)
                max = height[i+1];
            rightMax.put(i, max);
        }
        int res = 0;
        for(int i=1; i<n-1; i++){
            int left = leftMax.get(i), right = rightMax.get(i);
            //别忘记减去当前高度
            res += Math.min(left, right)>height[i]?Math.min(left, right)-height[i]:0;
        }
        return res;  
    }
}
第一次做, 双指针, 2ms, 在遍历每一根柱子时, 可能从左往右遍历, 也可能从右往左遍历, 举例来说, 如果左墙比右墙低, 就从左往右遍历, 因为此时柱子的存水量最多是左墙的高度; 这道题主要就是理解什么时候从左往右遍历, 什么时候从右往左遍历; 还需要两个变量分别存储左墙和右墙的索引, 注意如何更新墙的索引
/*
得理解height[leftMaxIndex] == height[rightMaxIndex]时,从哪边遍历都行, 例子[3,0,2,2,3]
*/
class Solution {
    public int trap(int[] height) {
        if(height==null || height.length < 3)
            return 0;
        //用两个变量分别存储左侧的最大值索引和右侧的最大值索引
        int leftMaxIndex=0, rightMaxIndex=height.length-1;
        //逐列判断
        int sum = 0;
        //双指针
        int left = 1, right = height.length-2;
        //while循环: 要遍历完每一根柱子
        while(left <= right){
            //height[leftMaxIndex] == height[rightMaxIndex]时,从哪边遍历都行
            //右边的墙更高, 则从左向右遍历
            if(height[leftMaxIndex] < height[rightMaxIndex]){
                //此时, 如果左墙比当前柱子高, 就能存住水
                if(height[leftMaxIndex] > height[left]){
                    sum += height[leftMaxIndex] - height[left];
                }
                //否则说明左墙比当前柱子低或者和当前柱子一样高, 更新左墙索引
                else{
                    leftMaxIndex = left;
                }
                //update
                left++;
            }
            //左边的墙更高或者两堵墙一样高, 则从右向左遍历
            else{
                //此时, 如果右墙比当前柱子高, 就能存住水
                if(height[rightMaxIndex] > height[right]){
                    sum += height[rightMaxIndex] - height[right];
                }
                //否则说明右墙比当前柱子低或者和当前柱子一样高, 更新右墙索引
                else{
                    rightMaxIndex = right;
                }
                //update
                right--;
            }
        }
        return sum;
    }
}
第一次做,拿空间换时间, 时间复杂度O(N),3ms, 空间复杂度O(N); 一列一列地处理, 不再重新求左右的最大值, 而是保存左右的最大值, 适当地进行更新; 左侧最大值好办, 主要是如何更新右侧最大值? 从右向左遍历! 别老是想着一遍完成任务, 其实两遍遍历,三遍遍历都是可以的, 没有增加时间复杂度的量级
class Solution {
    public int trap(int[] height) {
        if(height==null || height.length<3)
            return 0;
        
        int sum=0;
        //拿空间换时间
        int[] leftMax = new int[height.length];
        int[] rightMax = new int[height.length];
        //先求leftMax的各个值, leftMax[i]表示0,...,i对应的最大值
        leftMax[0] = height[0];
        for(int i=1; i<height.length; i++){
            leftMax[i] = Math.max(height[i], leftMax[i-1]);//竟然有点绕... 容易写错
        }
        //求rightMax的各个值, rightMax[i]表示i,...height.length-1对应的最大值
        rightMax[height.length-1] = height[height.length-1];
        for(int i=height.length-2; i>=0; i--){
            rightMax[i] = Math.max(height[i], rightMax[i+1]);
        }
        //开始逐列处理,第0列和第height.length-1列不能存水
        for(int i=1; i<height.length-1; i++){
            if(leftMax[i-1]>height[i] && rightMax[i+1]>height[i])
                sum = sum + Math.min(leftMax[i-1], rightMax[i+1]) - height[i];
        }
        return sum;
    }
}
第一次做, 时间复杂度O(N^2), 95ms, 空间复杂度O(1), 一列一列地计算; 对于当前列来说, 只有左侧的最大值和右侧的最大值都大于当前值时可能存水; 这道题耗时的地方在于,考虑每一列时都要重新计算其左右的最大值, 如果能把左右的最大值保存下来就好了!
/*
先递减再递增才能存住水
先写个O(N^2)的解法吧
*/
class Solution {
    public int trap(int[] height) {
        if(height==null || height.length<3)
            return 0;
        
        int leftMax=0, rightMax=0, sum=0;
        for(int i=1; i<height.length-1; i++){
            //找到左边的最大值
            leftMax = getMax(height, 0, i-1);
            //如果左侧最大值比当前值小或者相等,那么当前列不能存住水, 进入下一轮循环
            if(leftMax<=height[i])
                continue;
            //找到右侧的最大值
            rightMax = getMax(height, i+1, height.length-1);
            //如果右侧的最大值比当前值小或者相等, 那么当前列不能存水, 进入下一轮循环
            if(rightMax<=height[i])
                continue;
            //
            sum = sum + Math.min(leftMax, rightMax) - height[i];
        }
        return sum;
    }
    public int getMax(int[]arr, int i, int j){
        int max = 0;
        for(int k=i; k<=j; k++)
            max = Math.max(max, arr[k]);
        return max;
    }
}
题解, 双指针, 不再用数组存储最大值, 只用了两个常量
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;
}
LeetCode优秀例子(https://leetcode.com/problems/trapping-rain-water/discuss/17391/Share-my-short-solution.)

littlehaes
关注
专栏目录
leetcode -- 栈总结
李白-2017的博客
11-04 829
栈的相关题目也比较多，这里主要对栈中的easy，top 100 liked qusetions和top interviewquestions做了详细总结。 目录 1.栈实现队列 2.队列实现栈 3.包含min函数的栈 4.计算算式 5.给定序列判断出栈顺序是否可行 7. 括号匹配 8.与二叉树结合，遍历二叉树 9. 求一个区域的题目 10. 嵌套迭代器 ...
个人记录-LeetCode 42. Trapping Rain Water
ZhangJian的博客
12-03 912
LeetCode
leetcode Top 100 Liked Questions Python详解
林夕
04-19 2411
题目 难度 备注 15. 3Sum Medium 双指针 17. Letter Combinations of a Phone Number Medium 递归 15. 3Sum: 暴力解法，O(n3)O(n^3)O(n3) class Solution(object): def threeSum(self, nums): """ :...
[LeetCode] Top 100 Liked Questions
weixin_30684743的博客
09-02 392
[LeetCode] Top 100 Liked Questions # Title Acceptance Difficulty 1 Two Sum 38.80% Easy 2 Add Two Numbers 29.10% Medium 3 Longest Substring Without Repeating C...
Leetcode刷题指南和top100题目
热门推荐
lingpy的博客
03-03 6万+
原文链接：https://blog.csdn.net/qq_39521554/article/details/79160815 参考博文：https://blog.csdn.net/mmc2015/article/details/87200435 一、刷题方法 方法一：按照题目出现频率刷题 顺序参考文章最后的部分 方法二：标签法 按照网站给大家排列的不同tags，起到模块化的复习和学习作用。举...
leetcode top 100 题目汇总
weixin_34062329的博客
03-11 846
首先表达我对leetcode网站的感谢，与高校的OJ系统相比，leetcode上面的题目更贴近工作的需要，而且支持的语言广泛。对于一些比较困难的题目，可以从讨论区中学习别人的思路，这一点很方便。 经过一段时间的练习，我感觉自己的算法水平还是有很大的提升的。与学校开的算法导论的课程相比，我觉得实实在在的做题，比学习理论更符合我的认知方式。可能我属于那种脑子记不住，但是可以用“肌肉”去记忆的类型吧。...
Leetcode刷题指南
mmc2015的专栏
02-13 1万+
参考：https://blog.csdn.net/qq_39521554/article/details/79160815   二、刷题方法 方法一：按照题目出现频率刷题 顺序参考文章最后的部分 方法二：标签法 按照网站给大家排列的不同tags，起到模块化的复习和学习作用。举个例子：比如复习链表的内容，就选Linked List这部分的23个题目。刷完之后可以再总结一下常用的方法和数据结...
leetcode刷题从这里开始
funnyPython的博客
04-16 227
之前在leetcode上面漫无目的刷题，效果不是太好，后来有大神推荐如果要刷题，可以从Top 100 Liked 刷起，这些题特别的经典，最好能够做到用最优解来解决问题。这里我整理了一下， Top 100 Liked Questions 对号√ 错号× 题号 题目名字 难度 完成情况/次数 001 Two_Sum Easy 002 Add Two Numbers Mediu...
leetcode:LeetCode Top 100 Liked Questions | Top Interview Questions | LeetCode 用户最喜欢的100题 | 面试最容易被问到的题
05-10
LeetCode 指南 语言: Java 说明： 每道题在代码头部都添加了我的解题思路和批注，Eg: /***** * 287. Find the Duplicate Number * 题意：n+1个数属于[1~n]，找出重复的那个数 * 难度：Medium * 分类：Array, ...
Leetcode Top100题目和答案（Java完整版 面试必备）.zip
06-03
《LeetCode Top100题目和答案（Java完整版 面试必备）》这个压缩包文件是一个针对Java程序员的面试准备资源，包含了LeetCode上最受欢迎的前100道编程题目及其对应的Java解决方案。LeetCode是一个在线平台，提供了一...
leetcode题库-Leetcode_Questions.github.io:在leetcode的题库中记录我的学习心得
06-29
在本项目中，“LeetCode题库 - LeetCode_Questions.github.io”是一个开源资源，用于记录作者在LeetCode平台上的学习心得与解题经验。LeetCode是一个著名的在线编程挑战平台，它提供了各种算法题目，旨在帮助程序员...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1399
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
spring task的使用场景
qq_40603125的博客
10-13 78
spring任务调度框架约定的时间。
Backend - Java 基础
是萝卜干呀的博客
10-11 553
知识量决定了未来能走多远
Netty 相比原生IO模型的优势
lssffy的博客
10-09 625
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Hex编码
weixin_74305514的博客
10-13 88
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
Spring Boot 整合 Minio
cmh1008611的博客
10-09 915
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
初始Python篇（2）——逻辑控制、序列
最新发布
我要学编程的博客
10-14 806
程序的组织结构：顺序、选择、循环 pass空语句 猜数字小游戏 序列、序列相关操作
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值