纯新手，用for循环2小时攻破所谓的“接雨水”二维+三维甚至推广到更高维度

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量252 收藏 1
点赞数 1
文章标签： java 算法 开发语言 矩阵 数学建模
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62652913/article/details/132618990
版权

 这是题目

，很容易就看出接的雨水的形状是倒三角类型的，我觉得和for循环打印三角形差不多；

只是这个图像有三角形和烟囱形的形式，反正最上面雨水那一层总是比下面那一层的多。

浅浅画一个

以下是这道题的代码，虽然做出来了但是没提交leetcode，因为不知道咋写那种输入



import java.lang.*;
import java.util.Scanner;

/**
 * 0 0 1 0 2 1 0 1 3 2 1 2 1 0
 * 在n个柱子旁边加上地平线“0”，那么数组为a[n-1]和a[n+1]就为0
 * 用a[i] < a[i + n] && a[i] < a[i - 1]找到最小值，（n = 1、2、3...） ，然后count+1
 * 找到a[i-1]与a[i+n]之间的数，随着n的增大，里面的值就越多，我用for循环去count++;
 * 然后定义一个变量add（称为count之前的值），如果count一直在增加，那么就不扩大n，即区间的范围。
 * 当count==add，那么就增大区间，即n++
 * 
 * 关键代码：
 *         for (int n = 1;n<=size-2;){
 *             int add = count;
 *             for(int i = 1;i < size-1;i++){
 *                 if (i + n <size -1) {
 *                     if (a[i] < a[i + n] && a[i] < a[i - 1]) {
 *                         for (int j = 0; j < n; j++) {
 *                             a[i + j]++;
 *                             count++;
 *                         }
 *                     }
 *                 }
 *             }if( count == add){n++;}
 *         }
 * 
 * ---------------------------------------------------------------------------
 * size是你加了地平线的数组长度，size = n+2
 */
public class asd {
    public static void main(String[] args) {
        int count = 0;  //计算能接多少雨水
        Scanner s = new Scanner(System.in);
        System.out.println("输入你的数组长度为：");//size-2 = n
        final int size = s.nextInt();
        if (size <= 4){
            System.out.println("一共接了"+count+"滴水");
            System.exit(0);
        }
        int a[] = new int[size];
        a[0] = 0;
        for (int i = 1;i<size-1;i++){
            int x = s.nextInt();
            a[i] = x;
        }
        a[size-1] = 0;
        //打印现在的数组情况
        System.out.println("开始的数组情况为：");
        for (int i = 0;i<size;i++){
            System.out.print(a[i]+"\t");
        }


        //开始解题
        for (int n = 1;n<=size-2;){
            int add = count;
            for(int i = 1;i < size-1;i++){
                if (i + n <size -1) {
                    if (a[i] < a[i + n] && a[i] < a[i - 1]) {
                        for (int j = 0; j < n; j++) {
                            a[i + j]++;
                            count++;
                        }
                    }
                }
            }if( count == add){n++;}
        }



        //打印接水后的数组情况
        System.out.println();
        System.out.println("结束的数组情况为：");
        for (int i = 0;i<size;i++){
            System.out.print(a[i]+"\t");
        }
        System.out.println();
        System.out.println("一共接了"+count+"滴水");
    }
}

【没错，我猜你也想到了吧】

这种不规则形状的水咋办？先找底部的起点？然后走迷宫走出来？

那这样的呢？请问阁下该如何应对？稍微动动脑筋，

刚刚的 height = [0,1,0,2,1,0,1,3,2,1,2,1] 就当只是个一维的。
而我出的这个是二维的,可以表示成这样[

[0,0,0,0,0,0,1,0,0,0,0,0],

[0,0,0,0,1,0,1,1,1,0,0,0],

[0,0,0,0,1,0,1,1,1,1,0,1],

[1,1,1,0,1,0,1,0,0,0,0,1],

[1,0,0,0,1,0,1,1,0,0,0,1],

[1,1,0,0,1,0,0,0,1,0,1,1]]

那这就只不过是多了几行一维数组而已，只需再加个for循环而已，一行一行的判断，把1之间的0都变成1，再count就行了。

最开始那道接雨水的题也可以用这种方法做，只需要把一维变成二维，再把二维变成一维就行了

下面是代码

package com.newton.test;

import java.lang.*;
import java.util.Scanner;

/**
 * 默认雨水的高度小于9，（可以自行更改的）
 * 关键代码：
 * for (int n = 1;n<=size-2;){
 *             int add = count;
 *             for (int j = 0;j<9;j++) {
 *                 for (int i = 1; i < size - 1; i++) {
 *                     if (i + n < size - 1) {
 *                         if (a_copy[i][j] < a_copy[i + n][j] && a_copy[i][j] < a_copy[i - 1][j]) {
 *                             for (int m = 0; m < n; m++) {
 *                                 a_copy[i + m][j]++;
 *                                 count++;
 *                             }
 *                         }
 *                     }
 *                 }
 *             }if( count == add){n++;}
 *         }
 */
public class RainyDay_1_5 {
    public static void main(String[] args) {
        int count = 0;  //计算能接多少雨水
        Scanner s = new Scanner(System.in);
        System.out.println("输入你的数组长度为：");//size-2 = n
        final int size = s.nextInt();
        int a_copy[][] = new int[size][9];  //9代表的是雨水的高度的最大值
        if (size <= 4){
            System.out.println("一共接了"+count+"滴水");
            System.exit(0);
        }
        int b[] = new int[size];
        int a[] = new int[size];
        a[0] = 0;
        for (int i = 1;i<size-1;i++){
            int x = s.nextInt();
            a[i] = x;
        }
        a[size-1] = 0;
        //打印现在的一维数组情况
        System.out.println("开始的数组情况为：");
        for (int i = 0;i<size;i++){
            System.out.print(a[i]+"\t");
        }
        System.out.println();
        System.out.println("将一维数组变为二维...");
        for (int i = 0;i<size;i++){
            for (int j=0;j<a[i];j++){
                a_copy[i][j] = 1;
            }
        }
        //打印现在的二维数组情况
        System.out.println("现在的二维数组情况为：");
        for (int j = 0;j<9;j++){
            for (int i = 0;i<size;i++){
                System.out.print(a_copy[i][j]+"\t");
            }
            System.out.println();
        }

        //开始解题
        for (int n = 1;n<=size-2;){
            int add = count;
            for (int j = 0;j<9;j++) {
                for (int i = 1; i < size - 1; i++) {
                    if (i + n < size - 1) {
                        if (a_copy[i][j] < a_copy[i + n][j] && a_copy[i][j] < a_copy[i - 1][j]) {
                            for (int m = 0; m < n; m++) {
                                a_copy[i + m][j]++;
                                count++;
                            }
                        }
                    }
                }
            }if( count == add){n++;}
        }

        //打印现在的二维数组情况
        System.out.println("现在的二维数组情况为：");
        for (int j = 0;j<9;j++){
            for (int i = 0;i<size;i++){
                System.out.print(a_copy[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("将二维降为一维");
        //将二维数组降为一维
        int count_2;
        for (int j = 0;j<9;j++){
            for (int i = 0;i<size;i++){
                if (a_copy[i][j] == 1){
                    b[i]++;
                }
            }
        }

        //打印接水后的数组情况
        System.out.println();
        System.out.println("结束的数组情况为：");
        for (int i = 0;i<size;i++){
            System.out.print(b[i]+"\t");
        }
        System.out.println();
        System.out.println("一共接了"+count+"滴水");
    }
}

运行一下，

        好了，接下来是三维的接雨水了，题目是这样的

这样的

大家别被吓到了哦，草履虫都知道被子能装多少水得从杯口俯视着看，你看杯子侧面那只是凭经验猜测能装多少水。

那么，这一道题也还是二维的。刚刚第一题是从左往右判断a[i] < a[i + n] && a[i] < a[i - 1]。

这一题就得增加一个从上往下判断了。

解释在代码里面也有，自己看吧



import java.lang.*;
import java.util.Scanner;

/**
 * heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]
 * length = 8 ;width = 5
 * 1 4 3 1 3 2                       1  4   3 "3" 3  2     |                 1  4   3 "3" 3  2
 * 3 2 1 3 2 4   ---length--->7di    3 "3" "3" 3 "3" 4     | ---width-->0di  3 "3" "3" 3 "3" 4
 * 2 3 3 2 3 1                       2  3   3 "3" 3  1     |                 2  3   3 "3" 3  1
 * ——————————————————————————————————————————————————————————
 * 1 4 3 1 3 2                   1  4   3  1  3  2          |                 1  4   3 "3" 3  2
 * 3 2 1 3 2 4  ----width-->4di  3 "3" "3" 3 "3" 4          |---length-->3di  3 "3" "3" 3 "3" 4
 * 2 3 3 2 3 1                   2  3  3   2  3  1          |                 2  3   3 "3" 3  1
 * ——————————————————————————————————————————————————————————
 * 我们分别看 length的 和width的 
 * 很容易就看出，length和width重叠的那一部分才是真正该count++的地方
 *        1 4 3 1 3 2             1  4   3  1  3  2
 * 即为    3 2 1 3 2 4 ------>4di  3 "3" "3" 3 "3" 4
 *        2 3 3 2 3 1             2  3  3   2  3  1
 *
 * 例子1：length = 7 ，width = 7
 *  3 3 3 3 3
 *  3 2 2 2 3
 *  3 2 1 2 3
 *  3 2 2 2 3
 *  3 3 3 3 3
 *  例子2：length = 13, width = 13
 *  9 9 9 9 9 9 9 9 9 9 9
 *  9 8 8 8 8 8 8 8 8 8 9
 *  9 8 7 7 7 7 7 7 7 8 9
 *  9 8 7 6 6 6 6 6 7 8 9
 *  9 8 7 6 5 5 5 6 7 8 9
 *  9 8 7 6 5 0 5 6 7 8 9
 *  9 8 7 6 5 5 5 6 7 8 9
 *  9 8 7 6 5 5 5 6 7 8 9
 *  9 8 7 7 7 7 7 7 7 8 9
 *  9 8 8 8 8 8 8 8 8 8 9
 *  9 9 9 9 9 9 9 9 9 9 9
 *
 */

public class RainyDay_2 {
    public static void main(String[] args) {
        double count = 0;  //计算能接多少雨水
        Scanner s = new Scanner(System.in);
        System.out.println("输入你的数组长度为：");//length-2 = n
        final int length = s.nextInt();
        System.out.println("输入你的数组宽度为：");//width-2 = n
        final int width = s.nextInt();

        double a_copy[][] = new double[length][width];
        double moment[][] = new double[length][width];  // 全为0的暂时数组
        for (int j = 0;j<width;j++){
            for (int i = 0;i<length;i++){
                moment[i][j] = 0;
            }
        }
        if (length <= 4 && width <=4){
            System.out.println("一共接了"+count+"滴水");
            System.exit(0);
        }
        //补齐二维数组左侧的“0” ,其实数组自带补“0”
        double a[][] = new double[length][width];
        for (int j = 1;j<width-1;j++){
            a[0][j] = 0;
        }
        //输入二维数组
        for (int j = 1;j<width-1;j++){
            for (int i = 1;i<length-1;i++){
                int x = s.nextInt();
                a[i][j] = x;
            }
        }
        //补齐二维数组右侧的“0”,其实数组自带补“0”
        for (int j = 1;j<width-1;j++){
            a[length-1][j] = 0;
        }
        //打印现在的数组情况
        System.out.println("开始的数组情况为：");
        for (int j = 1;j<width-1;j++){
            for (int i = 1;i<length-1;i++){
                a_copy[i][j] = a[i][j];
                System.out.print((int)a[i][j]+"\t");
            }
            System.out.println();
        }

        //开始解题
        for (int n = 1;n<=length-2;){
            count = (int)count;
            double add = count;
            for (int j = 1;j<width-1;j++) {            //从第一排到第二排依次检测，横向的length i
                for (int i = 1; i < length - 1; i++) {
                    if (i + n < length) {
                        if (a[i][j] < a[i + n][j] && a[i][j] < a[i - 1][j]) {
                            for (int m = 0; m < n; m++) {
                                a[i + m][j] ++;
                                moment[i+m][j] ++;         //一个临时的moment[i][j]数组，可以暂时存放增加的痕迹
                                count = count + 0.001;  //count不能加一，但是需要微小变化
                            }
                        }
                    }
                }
            }if (count == add) {
                n++;
            }
        }
        for (int n = 1;n<=width-2;){
            double add = count;
            for (int j = 1;j<width-1; j++) {      //从第一列到第二列依次检测 纵向的width j
                for (int i = 1; i < length - 1; i++) {
                    if (j + n < width) {               //用新的a_copy来增加，如有之前增加的痕迹再增加count
                        if (a_copy[i][j] < a_copy[i][j + n] && a_copy[i][j] < a_copy[i][j - 1] && (moment[i][j] > 0)) {
                            for (int m = 0; m < n; m++) {
                                a_copy[i][j + m] = a_copy[i][j + m] + 1;
                                count = count + 1;
                            }
                        }
                    }
                }
            }if (count == add) {
                n++;
            }
        }
        //打印接水后的数组情况
        System.out.println();
        System.out.println("结束的数组情况为：");
        for (int j = 1;j<width-1;j++){
            for (int i = 1;i<length-1;i++){
                System.out.print((int)a_copy[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println();
        System.out.println("一共接了"+(int)count+"滴水");
    }
}

运行一下，怕你们不信

至于推广到多维度的，比如说四维的东西能接多少雨水.....也许只是多一个for循环，感兴趣的话可以尝试去思考思考，顺便思考一下四维的杯子长啥样吧哈哈哈

及时补水
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
2013高考英语 单选全攻破 第二单元 第二部分 单选命题策略分析与解题技巧
08-07
2013高考英语 单选全攻破 第二单元 第二部分 单选命题策略分析与解题技巧
考研英语指导：攻破完形填空的三大法宝.pdf
03-13
考研英语指导：攻破完形填空的三大法宝.pdf
接雨水、二维接雨水
Pain is inevitable but suffering is optional.
05-31 209
接雨水
【经典算法题】接雨水
weixin_42638946的博客
11-27 6742
【经典算法题】接雨水 Leetcode 0042 接雨水 题目描述：Leetcode 0042 接雨水 分析 本题的考点：数组。 核心思路：我们求出每个位置能存储的水量，最后加到一起就可以得到答案，如下图五个地方的水量相加即可： 那么如何求解每个位置可以存放的雨水？我们可以预先处理处两个数组left_max和right_max。left_max[i]表示height[0]~height[i]中最高的柱子，right_max[i]表示height[i]~height[n-1]中最高
花式接雨水
supermouse的博客
03-07 428
文章目录第 11 题 怎样接最多的雨水思路一：暴力求解思路二：双指针第 42 题 能够接多少雨水思路一：暴力求解思路二：动态规划思路三：栈思路四：双指针（大杀器）第 407 题 第 42 题升级版——三维地图接雨水解题思路 今天总结一下 LeetCode 上的几道跟接雨水有关的题目。 第 11 题 怎样接最多的雨水 题目链接：11. Container With Most Water 原题如下： ...
LeetCode——–接雨水python
12-21
题目不重述了。 小菜一枚，思路还是比较欠缺，按照leetcode题解的精选，用python写了一下。加深理解吧。 按行接雨水： 思路：首先寻找数组的最大值，即最多一共有几行。然后分别求每一行的雨水量。 从第一行开始，第一种情况是遇到比第一行低的块，可以存到一方水；第二种情况是遇到和第一行一样高或者比第一行要高的块，重新开始计算雨水量。 直到最高行，雨水量计算完毕。思路比较清晰，可以看力扣官网题解精选有图。 python代码： class Solution: def trap(self, height: List[int]) -> int: heightest=max
接雨水系列题目
1160200515的博客
11-07 402
接雨水系列题目 leetcode上的两道接雨水的题目，一道是基础版的，另一道是进阶版的 42. 接雨水 407. 接雨水 II 下面来看具体题目 42. 接雨水 题目 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 示例 1： 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出：6 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）
3D接雨水2（leetcode）——Java实现（又是想上吊的一天）
apple_51673523的博客
11-03 6047
本以为今天有是平平的一天，结果早上起床，说突发疫情，停止线下课，然后十分开心。打开leetcode准备每日一题，结果给我做到自闭，一度想放弃！！接下来就让我们看一看这样的题。。。有多么恶心 给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。 示例 1: 输入: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]] 输出: 4 解释: 下雨后，雨水将会被上图蓝色的方块中。总的接
3D接雨水——考察知识点
Merria28的专栏
01-15 3052
leetcode中的接雨水问题 从2D到3D，考察的知识点完全不同：2D中要求掌握双指针算法技巧，3D中要求掌握广度优先搜索算法+优先队列使用技巧 针对这个3D接雨水问题，罗列知识点 BFS： 广度优先搜索算法 breadth first search / broad first search DFS： 深度优先搜索算法 deep first search 数据结构—...
leetcode 407.接雨水II(超级简单易懂)
m0_58032574的博客
02-18 1190
大家好，这里是张哈希刷题频道。今天给大家带来一道有意思的题目，"接雨水"。看到好多小伙伴，遇到了面试官想kill -9结束面试，抛出了这个3D接雨水核弹（前些年抛红黑树线段树之类的），接不下来基本上就宣布下线，此时一般可以直接带上简历走人了 ... （开个玩笑，可以继续厚脸皮硬刚，坚持我能赢）这个题目听起来很恐怖，其实是个老派难题。我们从头到尾把这个题目的解决过程讲解一遍。首先来看题目,题目大意是给你一个二维的height map,让你求这个地形能够接的雨水总量。
运用QC方法攻破砼支撑爆破难关2(PPT32页).ppt
09-23
运用QC方法攻破砼支撑爆破难关2(PPT32页).ppt
攻破C语言笔试与机试难点V0.31 .pdf
06-28
攻破C语言笔试与机试难点，规范代码
2013高考英语 单选全攻破 第五单元 第二章 阅读理解文章分类分析
08-07
2013高考英语 单选全攻破 第五单元 第二章 阅读理解文章分类分析
力扣 407. 接雨水 II
大家好~我是SP_FA~
11-04 169
题目链接 首先要知道一点：这个矩阵的边缘是无法接水的，如果我们设 water[i][j]water[i][j]water[i][j] 是 (i,j)(i, j)(i,j) 点水的高度，那么对于矩阵边缘来所，water[i][j]=heightMap[i][j]water[i][j]=heightMap[i][j]water[i][j]=heightMap[i][j]，接到水的体积就是 water[i][j]−heightMap[i][j]=0water[i][j]-heightMap[i][j]=0wate
LeetCode42. 接雨水
Closure
08-25 328
难度：困难 题目描述： 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 示例 1： 输入： height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出： 6 解释： 上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 示例 2： 输入： height = [4,2,0,3,2,5] 输出： 9 提示： n == height
【LeetCode】42. 接雨水
weixin_41888257的博客
09-18 772
42. 接雨水（二维） 一、题目描述 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 示例: 输入: [0,1,0,2,1,0,1,3,2,1,2,1] 输出: 6 二、解题思路 & 代码 2.1 按列求 求每一列的水，我们只需要关注当前列，以及左边最高的墙，右边最高的墙就够了。 装水的多少，当然根据木
Python实现3D接雨水
走向CTO的路上...
11-09 291
鱼弦：CSDN内容合伙人、CSDN新星导师、全栈领域创作新星创作者 、51CTO(Top红人+专家博主) 、github开源爱好者（go-zero源码二次开发、游戏后端架构 https://github.com/Peakchen）例如，在城市设计中，可以利用该算法评估建筑物和道路的排水系统，确定最佳的雨水收集策略。该算法的原理是通过遍历边界上的点，并使用优先队列（堆）来选择最低的点进行扩展。该算法基于优先队列（堆）的思想，通过从边界点开始，不断选择最低的点并向内部扩展，计算接到的雨水量。
【算法】经典算法题：接雨水 I & II（Python实现）
BlueBlue
05-16 1473
一、接雨水 I leetcode.42 链接：https://leetcode.cn/problems/trapping-rain-water/ 难度：hard 这里介绍了两种方法：动态规划（时间和空间复杂度都为O(n)），双指针（时间复杂度O(n)，空间复杂度O(1)）。 1、动态规划 时间复杂度：O(n) 空间复杂度：O(n) （1）算法原理 首先，维护两个数组： leftMax：第i个元素表示第i个柱子及左边位置中，height的最大高度。 righ...
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 270
借助jdeps分析出jar包的增量文件
与加密算法相比，MAC函数更易被攻破。
06-01
B。与加密算法相比，MAC函数的安全性要更强一些。MAC函数是一种基于密钥的哈希函数，它使用密钥对消息进行加密，生成一个固定长度的认证码，用于验证消息的完整性和真实性。而加密算法是一种将明文转换为密文的算法，用于保护数据的机密性。由于MAC函数只需要保证认证码的安全性，而加密算法需要保证密钥的安全性和算法的安全性，因此，MAC函数的安全性相对来说更容易得到保障。但是，MAC函数的密钥管理和分发问题也需要得到合理的解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值