算法(12)--盛水、最大矩形、接雨水、加油站

原创已于 2025-08-24 10:13:05 修改 · 618 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2020-10-16 21:00:40 首次发布

算法题专栏收录该内容

20 篇文章

订阅专栏

盛水、接雨水、加油站

Abstract
11. 盛最多水的容器
84. 柱状图中最大的矩形
42. 接雨水
407. 接雨水 II - TBD
134. 加油站
- 暴力 o(N^2)
- 贪心 o(n)

Abstract


// 11. 盛最多水的容器 - 两根线之间的求面积 -  双指针从两边往中间走，每次移动矮的那根，下一次才有更有可能变大的可能性。
int maxArea(vector<int>& height);

// 84. 柱状图中最大的矩形 - 两根围成的面积受制于中间的高，所以和盛水的容器不一样
有点难

// 42. 接雨水 - 一维 - 所有洼地的总面积 - 每个洼地能解多少雨水 取决于，左右两边的围水高度和池塘底部高度
// 逐个计算每个位置能盛的水，怎么保证水能被拦住？短板决定水不会溢出！
 int trap(vector<int>& height)


// 407. 接雨水 II - 二维, 需四个辅助矩阵？没你想的那么简单 TODO
int trapRainWater(vector<vector<int>>& heightMap);

// 134. 加油站 - 如有油总和有富裕，那我们总能找到一个多油的加油站出发，把全程跑完。遍历一次找到这个加油站即可
int canCompleteCircuit(vector<int>& gas, vector<int>& cost);

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。

class Solution:
    def maxArea1(self, height: List[int]) -> int:
    	"""
    	@note 暴力法，遍历所有可以盛水的容器， 49 / 61 个通过的测试用例
    	"""
        n = len(height)
       	vol_arrary = [[0] * n for _ in range(n)]
        res = 0
        for i in range(0, n):
            for j in range(i+1, n):
                w = j - i
                h = min(height[i], height[j])
                vol_arrary[i][j] = w * h
                res = max(res, vol_arrary[i][j])
        return res

    def maxArea2(self, height: List[int]) -> int:
        """
        @note 动态规划-key 在左右边界往里缩的时候，让短板边长，才有使盛水量变多的可能
			array[i][j] = w * h， h =  min(height[i], height[j])
	        每次移动短板，有效成水高度h   有变大的可能， 面积可能会变大
	        每次移动高板，有效成水高度h， 不变/变小      面积一定变小
        """
        n = len(height)
        left, right = 0, n-1
        res = 0
        while(left < right):

            vol = (right - left) * min(height[left], height[right])
            res = max(res, vol)

            if height[left] <= height[right]:
                left += 1
            else:
                right -= 1
        return res

84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。求在该柱状图中，能够勾勒出来的矩形的最大面积。

1.暴力法

两柱子间矩形的高由他们之间的最矮的柱子决定。因此可以遍历所有两两柱子形成矩形的面积。求一个最大值o（n^3）。94/96

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        n=len(heights)
        if n==0:
            return 0
        res=max(heights)
        #print(res)
        for i in range(n):
            for j in range(i+1,n):
                h=min(heights[i:j+1])
                s=h*(j-i+1)
                #print(h,j-i+1,s)
                res=max(res,s)
        return res

2.优化暴力

每次求最低柱子的时候不用全部求最小，只要用新加进来的柱子和当前的比较求最小就可以了。 $o(n^2)$ 还是不过94/96

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        n=len(heights)
        if n==0:
            return 0
        res=max(heights)
        #print(res)
        for i in range(n):
            h=heights[i]
            for j in range(i+1,n):
                h=min(h,heights[j])
                s=h*(j-i+1)
                #print(h,j-i+1,s)
                res=max(res,s)
        return res

2.分治

最大矩形的面积存在三种情况
1.确定了最矮柱子之后，矩形尽可能往两边扩展
2.最矮柱子左边最大面积矩形
3.最矮柱子右边最大面积矩形 95/96

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        n=len(heights)
        if n==0:
            return 0
        def calculateArea(heights,s,e):
            if s>e:
                return 0
            min_index=s
            for i in range(s,e+1):
                if heights[i]<heights[min_index]:
                    min_index=i
            le_area=calculateArea(heights,s,min_index-1)
            ri_area=calculateArea(heights,min_index+1,e)
            mi_area=heights[min_index]*(e-s+1)
            return max(mi_area,le_area,ri_area)
        res=calculateArea(heights,0,n-1)
        return res

4.优化分治

Segment tree solution 分段树的解法，这是什么鬼

5.堆栈

-1 放进栈的顶部来表示开始
初始化时，按照从左到右的顺序，不断将柱子的下标放进栈中，直到遇到相邻柱子呈下降关系，也就是 a[i-1] > a[i]a[i−1]>a[i]。现在，我们开始将栈中的序号弹出，直到遇到 stack[j]stack[j] 满足 $a\big[stack[j]\big] \leq a[i]a[stack[j]]≤a[i]$
每次我们弹出下标时，我们用弹出元素作为高形成的最大面积矩形的宽是当前元素与 stack[top-1]之间的那些柱子

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        n=len(heights)
        if n==0:
            return 0
        s=[-1]
        res=0
        for i in range(n):
            while(s[-1]!=-1 and heights[s[-1]]>=heights[i]):
                h=heights[s.pop()]
                area=h*(i-s[-1]-1)
                res=max(res,area)
            s.append(i)

        while(s[-1]!=-1):
            h=heights[s.pop()]
            area=h*(n-s[-1]-1)
            res=max(res,area)
        return res

42. 接雨水

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

class Solution {
public:
    int trap(vector<int>& height) {
        // 么个位置能解多少雨水，主要取决于，左右两边的高度，中低的那个
        // 逐个计算，怎么保证水能被拦住，不溢出呢
        int n = height.size();
        vector<int> left_max(n, height[0]);
        vector<int> right_max(n, height[n-1]);
        for (int i = 1; i < n; i++) {
            left_max[i] = max(left_max[i-1], height[i]);
            right_max[n-1-i] = max(right_max[n-i], height[n-1-i]);
        }
        int res = 0;
        for (int i = 0; i < n; i++) {
            res += min(left_max[i], right_max[i]) - height[i];
        }
        return res;
    }
};

407. 接雨水 II - TBD

给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。

134. 加油站

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

说明:
如果题目有解，该答案即为唯一答案。
输入数组均为非空数组，且长度相同。
输入数组中的元素均为非负数。

示例 1:

输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]

输出: 3

解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。

示例 2:

输入:
gas = [2,3,4]
cost = [3,4,3]

输出: -1

解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周

暴力 o(N^2)

受示例2启发，可以采用遍历加油站数组，判断从每一个gas[i]出发能否环公路行驶一周。
从加油站 i 出发时，每到一个加油站判断，油量是否够跑到下一个加油站，若无法到达，则加油站 i 出发的策略不可行，判断下一个加油站的可行性。

判断条件：（当前的油量=剩余油量+能获取的油量）<(到下一个加油站要消耗的油量：cost[i])无法到达

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        """
        :type gas: List[int]
        :type cost: List[int]
        :rtype: int
        """
        cur=0
        flag=0
        res=-1
        for i,var in enumerate(gas):
            cur = 0
            for j in range(0,len(gas)):
                ind=int((i+j)%len(gas))
                cur=cur+gas[ind]
                if cur-cost[ind]<0:
                    break
                cur=cur-cost[ind]
                if j==len(gas)-1:
                    flag=1
            if flag==1:
                return i
        return res

31个用例，过了30个，超出时间限制！！！

贪心 o(n)

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        int cur_oil = 0, total_oil = 0;
        int start = 0;
        for (int i = 0; i < n; i++) {
            if (cur_oil < 0) {
                start = i;
                cur_oil = 0;
            }
            cur_oil += gas[i] - cost[i];
            total_oil += gas[i] - cost[i];
        }
        if (total_oil < 0) { // 如有总和有富裕，那我们总能找到一个多油的加油站出发，把全程跑完
            return -1;
        } else {
            return start;    // 找到这个加油站，仅需遍历一次数组
        }
    }
};