【数据结构和算法】盛最多水的容器

news2024/9/24 9:28:08

其他系列文章导航

Java基础合集
数据结构与算法合集

设计模式合集

多线程合集

分布式合集

ES合集

文章目录

其他系列文章导航

文章目录

前言

一、题目描述

二、题解

2.1 方法一：暴力枚举

2.2 方法二：双指针

三、代码

3.1 方法一：暴力枚举

3.2 方法二：双指针

四、复杂度分析

4.1 方法一：暴力枚举

4.2 方法二：双指针

前言

这是力扣的 11 题，难度为中等，解题方案有很多种，本文讲解我认为最奇妙的两种。

一、题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

n == height.length
2 <= n <= 105
0 <= height[i] <= 104

二、题解

2.1 方法一：暴力枚举

思路与算法：

顾名思义，暴力枚举，设定两个循环。

第一个循环，循环左挡板。
第二个循环，循环右挡板。

每次计算 area ，存入 maxArea 。

面积公式：S(i,j)=min(h[ i ] ,h[ j ])×(j−i)

2.2 方法二：双指针

思路与算法：

在每个状态下，无论长板或短板向中间收窄一格，都会导致水槽底边宽度 −1 变短：

若向内移动短板，水槽的短板 min(h[i],h[j]) 可能变大，因此下个水槽的面积可能增大。
若向内移动长板，水槽的短板 min(h[i],h[j]) 不变或变小，因此下个水槽的面积一定变小。

因此，初始化双指针分列水槽左右两端，循环每轮将短板向内移动一格，并更新面积最大值，直到两指针相遇时跳出；即可获得最大面积。

算法流程：

初始化：双指针 i , j 分列水槽左右两端；
循环收窄：直至双指针相遇时跳出；
更新面积最大值 res ；
选定两板高度中的短板，向中间收窄一格；
返回值：返回面积最大值 res 即可；

三、代码

3.1 方法一：暴力枚举

Java版本：

class Solution {
    public int maxArea(int[] height) {
        int n = height.length, max = 0, area;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                area = Math.min(height[i], height[j]) * (j - i);
                if (area > max) max = area;
            }
        }
        return max;
    }
}

C++版本：

class Solution {
public:
    int maxArea(vector<int>& height) {
        int n = height.size(), maxArea = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int area = min(height[i], height[j]) * (j - i);
                maxArea = max(maxArea, area);
            }
        }
        return maxArea;
    }
};

Python版本：

class Solution:
    def maxArea(self, height: List[int]) -> int:
        n = len(height)
        max_area = 0
        for i in range(n):
            for j in range(i+1, n):
                area = min(height[i], height[j]) * (j - i)
                max_area = max(max_area, area)
        return max_area

3.2 方法二：双指针

Java版本（易懂版）：

class Solution {
    public int maxArea(int[] height) {
        int i = 0, j = height.length - 1, max = 0, area;
        while (i != j) {
            area = Math.min(height[i], height[j]) * (j - i);
            if (area > max) max = area;
            if (height[i] < height[j]) {
                i++;
            } else {
                j--;
            }
        }
        return max;
    }
}

Java版本（优化版）：

class Solution {
    public int maxArea(int[] height) {
        int i = 0, j = height.length - 1, max = 0;
        while (i != j) {
            max = height[i] < height[j] ?
                    Math.max(max, (j - i) * height[i++]) : Math.max(max, (j - i) * height[j--]);
        }
        return max;
    }
}

C++版本：

class Solution {
public:
    int maxArea(vector<int>& height) {
        int i = 0, j = height.size() - 1, max_area = 0;
        while (i < j) {
            max_area = max(max_area, (j - i) * min(height[i], height[j]));
            if (height[i] < height[j]) {
                i++;
            } else {
                j--;
            }
        }
        return max_area;
    }
};

Python版本：

class Solution:
    def maxArea(self, height: List[int]) -> int:
        i, j, max_area = 0, len(height) - 1, 0
        while i < j:
            max_area = max(max_area, (j - i) * min(height[i], height[j]))
            if height[i] < height[j]:
                i += 1
            else:
                j -= 1
        return max_area