【力扣Leetcode题解系列之0011—Container With Most Water 盛最多水的容器：多语言实现与拓展】

最新推荐文章于 2026-06-17 20:26:24 发布
原创 最新推荐文章于 2026-06-17 20:26:24 发布 · 721 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#leetcode #算法 #盛水容器 #python #java

11. Container With Most Water 盛最多水的容器：多语言实现与拓展

一、题目分析

给定 n 个非负整数 a1, a2, ..., an，每个数代表坐标 (i, ai) 处的一个点。绘制 n 条垂直线，使得第 i 条线的两个端点分别为 (i, ai) 和 (i, 0)。找到两条线，它们与 x 轴构成一个容器，使得该容器能容纳最多的水。注意容器不能倾斜，且 n 至少为 2。

二、常用解法

双指针法

  1. 思路：使用两个指针，一个指向数组的开头（左指针 l），一个指向数组的末尾（右指针 r）。计算当前指针所指元素构成的容器面积，即 min(height[l], height[r]) * (r - l)。然后，将较短的指针向中间移动，因为较短边决定了容器的高度，移动较短边有可能找到更高的边，从而得到更大的面积。每次移动后更新最大面积。
  2. 优点：这种方法避免了暴力解法中对所有可能组合的计算，将时间复杂度从 O(n2)O(n^2)O(n2) 降低到 O(n)O(n)O(n)。

三、多语言实现

Python实现

class Solution:
    def maxArea(self, height):
        ans = 0
        l, r = 0, len(height) - 1
        while l < r:
            ans = max(ans, min(height[l], height[r]) * (r - l))
            if height[l] < height[r]:
                l += 1
            else:
                r -= 1
        return ans

Java实现

class Solution {
    public int maxArea(int[] height) {
        int ans = 0;
        int l = 0, r = height.length - 1;
        while (l < r) {
            ans = Math.max(ans, Math.min(height[l], height[r]) * (r - l));
            if (height[l] < height[r]) {
                l++;
            } else {
                r--;
            }
        }
        return ans;
    }
}

C实现

#include <stdio.h>
#include <stdlib.h>

int maxArea(int* height, int heightSize) {
    int ans = 0;
    int l = 0, r = heightSize - 1;
    while (l < r) {
        int area = (r - l) * (height[l] < height[r]? height[l] : height[r]);
        ans = ans > area? ans : area;
        if (height[l] < height[r]) {
            l++;
        } else {
            r--;
        }
    }
    return ans;
}

C++实现

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

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

Go实现

package main

import "fmt"

func maxArea(height []int) int {
    ans := 0
    l, r := 0, len(height)-1
    for l < r {
        area := (r - l) * min(height[l], height[r])
        if area > ans {
            ans = area
        }
        if height[l] < height[r] {
            l++
        } else {
            r--
        }
    }
    return ans
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

四、算法复杂性分析

  1. 时间复杂度：双指针法中，指针 l 和 r 最多遍历数组一次，因此时间复杂度为 O(n)O(n)O(n)，其中 n 是数组 height 的长度。
  2. 空间复杂度：所有实现中，除了输入数组外，只使用了常数级别的额外空间（如指针变量和存储最大面积的变量），所以空间复杂度为 O(1)O(1)O(1)。

五、题目扩展及难度加深

扩展题目1：三维容器问题

假设现在是在三维空间中，给定 n 个长方体的底面边长数组 lengths 和高度数组 heights，每个长方体的底面边长为 lengths[i]，高度为 heights[i]。要选择两个长方体，使得它们与底面构成的三维容器能容纳最多的液体。这里液体的高度由两个长方体中较矮的那个决定，底面面积由两个长方体底面边长中较短的那个与它们之间的距离决定。

扩展题目2：可变挡板高度

假设挡板的高度可以在一定范围内动态变化，例如，每次移动指针时，挡板高度可能会随机增减一个较小的值。如何在这种情况下找到最大盛水量？

难度加深题目：多约束条件下的盛水问题

增加约束条件，例如某些挡板之间存在障碍物，不能同时选择，或者选择某些挡板会有额外的成本。如何在这些复杂约束下找到能盛最多水的容器？

六、应用场合

  1. 资源分配优化：在一些资源分配场景中，如网络带宽分配，每个节点有不同的带宽上限，需要找到两个节点之间的最优分配方式，以最大化传输的数据量，类似于找到能盛最多水的容器。
  2. 图像处理：在图像边缘检测或形状识别中，可能需要找到图像中两个边界之间的最大区域，该区域的大小受边界的某些属性限制，类似于本题寻找最大面积的容器。
  3. 数据挖掘：在时间序列数据中，寻找两个时间点之间的最大某种度量值，且该度量值受这两个时间点对应数据值的限制，类似于本题找最大面积。

12. Integer to Roman 整数转罗马数字：全面解析与拓展

一、题目分析

罗马数字由七个不同的符号表示：I（1）、V（5）、X（10）、L（50）、C（100）、D（500）和 M（1000）。通常罗马数字从左到右按从大到小的顺序书写，但存在六种减法的特殊情况：I 可放在 V（5）和 X（10）前表示 4 和 9；X 可放在 L（50）和 C（100）前表示 40 和 90；C 可放在 D（500）和 M（1000）前表示 400 和 900。给定一个在 1 到 3999 范围内的整数，将其转换为罗马数字。

二、常用解法

贪心算法解法

  1. 思路：建立一个整数与罗马数字符号的对应关系表，从最大的整数开始，依次检查输入整数中包含多少个该整数对应的罗马数字符号。若包含，则将对应的罗马数字符号添加到结果字符串中，并从输入整数中减去该整数。重复此过程，直到输入整数为 0。这种方法利用了贪心策略，每次都尽可能地使用最大的罗马数字符号来表示输入整数，从而保证了结果的正确性和唯一性。
  2. 优点：算法思路清晰，实现简单，能够高效地完成转换任务。

三、多语言实现

Python实现

class Solution:
    def intToRoman(self, num):
        values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
        symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
        result = ""
        for i in range(len(values)):
            while num >= values[i]:
                result += symbols[i]
                num -= values[i]
        return result

Java实现

class Solution {
    public String intToRoman(int num) {
        int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        String[] symbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < values.length; i++) {
            while (num >= values[i]) {
                result.append(symbols[i]);
                num -= values[i];
            }
        }
        return result.toString();
    }
}

C实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* intToRoman(int num) {
    int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
    char* symbols[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    char* result = (char*)malloc(16 * sizeof(char));
    result[0] = '\0';
    for (int i = 0; i < 13; i++) {
        while (num >= values[i]) {
            strcat(result, symbols[i]);
            num -= values[i];
        }
    }
    return result;
}

C++实现

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class Solution {
public:
    string intToRoman(int num) {
        vector<int> values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        vector<string> symbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        string result = "";
        for (int i = 0; i < values.size(); i++) {
            while (num >= values[i]) {
                result += symbols[i];
                num -= values[i];
            }
        }
        return result;
    }
};

Go实现

package main

import (
    "fmt"
)

func intToRoman(num int) string {
    values := []int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}
    symbols := []string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}
    result := ""
    for i := 0; i < len(values); i++ {
        for num >= values[i] {
            result += symbols[i]
            num -= values[i]
        }
    }
    return result
}

四、算法复杂性分析

  1. 时间复杂度：算法中有两层循环，外层循环遍历整数与罗马数字符号对应关系表，共 13 次（因为有 13 种不同的罗马数字表示），内层循环在每次外层循环中最多执行 num / values[i] 次。由于 num 的最大值为 3999，而每次内层循环至少会使 num 减少一个正数，所以总的时间复杂度为 O(1)O(1)O(1)。因为无论输入 num 是多少，执行的操作次数都是有限且固定的，不随输入规模的变化而变化。
  2. 空间复杂度：所有实现中，除了输入的整数 num 外，额外使用的空间主要是用于存储对应关系表（values 和 symbols）以及结果字符串。存储对应关系表的空间是固定的，不随输入 num 的变化而变化，结果字符串的长度最大为 15（例如 3999 对应的罗马数字 “MMMCMXCIX”），所以空间复杂度为 O(1)O(1)O(1)。

五、题目扩展及难度加深

扩展题目1：支持更大范围的整数转换

假设需要支持将 1 到 3999999 的整数转换为罗马数字。这需要扩展现有的对应关系表，增加新的罗马数字表示，如 M 可以重复表示更大的数（如 MMM 表示 3000，MMMM 表示 4000 等），或者引入新的符号来表示更大的数量级。同时，算法需要考虑如何高效地处理这种扩展后的转换逻辑。

扩展题目2：罗马数字与整数的双向转换

不仅要实现整数到罗马数字的转换，还要实现罗马数字到整数的转换。这需要编写一个反向的转换函数，通过解析罗马数字字符串，根据罗马数字的规则计算出对应的整数值。实现过程中需要处理好减法规则（如 IV 表示 4，IX 表示 9 等）以及字符顺序的正确性。

难度加深题目：带条件的罗马数字转换

增加一些特殊条件，例如，某些罗马数字组合在特定场景下有不同的表示方式，或者某些整数不能用常规的罗马数字表示方法，需要使用特殊的表示形式。这要求在转换过程中不仅要遵循基本的转换规则，还要根据这些特殊条件进行额外的处理，大大增加了算法的复杂性。

六、应用场合

  1. 历史研究与文化传承：在历史、考古等领域，罗马数字常用于表示年份、历史事件发生的顺序等。通过将整数转换为罗马数字，可以更好地理解和研究古代文献、历史记录等，有助于文化传承和学术研究。
  2. 排版与编号：在书籍排版、文档编号等方面，罗马数字有时会用于表示章节、附录等的编号，以增加文档的专业性和独特性。将整数转换为罗马数字可满足这种排版和编号的需求。
  3. 密码学与编码：在一些简单的密码学应用或特定的编码系统中，罗马数字可以作为一种特殊的编码方式。整数到罗马数字的转换可作为编码过程的一部分，为数据提供一定程度的保密性和独特性。
11.乘最多水的容器
sinat_41619762的博客
08-03 527
题目描述 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器，且 n 的值至少为 2。 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 示例： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 双指针法
图解LeetCode11：盛最多水的容器(多种解法)
weixin_46429290的博客
12-02 2014
LeetCode11：盛最多水的容器 给你n个非负整数a1，a2，… … ，an，每个数代表坐标中的一个点(i, a)。在坐标内画n条垂直线，垂直线i的两个端点分别为(i, ai)和(i, 0)。找出其中的两条先，使得它们与x轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器 示例： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 输入：[1,1] 输出：1 提示： n == height.length 2 <= n <= 10^5 0 <= height[i] &l
LeetCode - 11 盛最多水的容器
CSDN
09-01 1716
也就是说 h[R1] * (R1 - L1 + 1) 的结果是肯定大于 h[L] * (R - L + 1) 的，因此这里 L 虽然没有匹配到最优高柱 R1，但是 R1 作为矮柱时的容器肯定比当前 R1 作为高柱时的容器盛水更多。容器内水的容量大小 V，取决于容器两端中的较短柱子h_min，因此为了使得容器内水尽可能的多，我们应该找到距离 h_min 柱子最远的，且高度>= h_min 的另一个柱子。解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。输入：height = [1,1]
盛最多水的容器Container With Most Water求max的最佳算法，举一反三
拉丁解牛技术专栏
09-03 1685
        原题： 给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器，且 n 的值至少为 2。 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此...
盛最多水的容器
LiuZihao97的博客
06-03 173
题目描述：给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 题目地址：https://leetcode-cn.com/problems/container-with-most-water/ 思路： 1、使用穷举法，依次从左到右选取基点柱子，再与右边剩余的柱子进行计算，取最大值。 2、双指针法，i、j分别指向数组的
【LeetCode】11. Container With Most Water 盛最多水的容器
负雪明烛
09-23 4014
【LeetCode】11. Container With Most Water 解题报告（Python） 作者： 负雪明烛 id： fuxuemingzhu 个人博客： http://fuxuemingzhu.cn/ 题目地址：https://leetcode.com/problems/container-with-most-water/description/ 题目描述： Given...
Leetcode 0011: Container With Most Water
weixin_43946031的博客
02-15 130
题目描述： Given an input string (s) and a pattern §, implement regular expression matching with support for ‘.’ and ‘’ where: ‘.’ Matches any single character.​​​​ '’ Matches zero or more of the preceding element. The matching should cover the entire input st
LeetCode Algorithm 0011 - 0015
DarkRabbit的专栏
09-21 317
0011 - Container With Most Water (Medium) 0012 - Integer to Roman (Medium) 0013 - Roman to Integer (Easy) 0014 - Longest Common Prefix (Easy) 0015 - 3Sum (Medium)
LeetCode11. Container With Most Water （思路及python解法）
AIpush的博客
12-19 305
Givennnon-negative integersa1,a2, ...,an, where each represents a point at coordinate (i,ai).nvertical lines are drawn such that the two endpoints of lineiis at (i,ai) and (i, 0). Find two...
LeetCode--491.递增子序列（回溯算法）
Coding...
06-16 169
解题思路 这道题要求找出数组中所有不同的递增子序列，序列长度至少为2。由于数组未排序且可能包含重复元素，需要使用回溯算法结合剪枝策略来高效解决问题。 关键点： 回溯框架：通过递归遍历所有可能的子序列组合 树层去重：使用HashSet记录当前层已使用的数字，避免重复计算 递增判断：确保新加入数字不小于序列最后一个数字 结果收集：当路径长度≥2时保存结果 实现细节： 不排序数组，保持原始顺序 每层递归维护独立的used集合，防止同层重复 及时剪枝，跳过不满足递增条件的数字 注意回溯时要恢复状态 该算法时间复杂度
leetcode 2130. 链表最大孪生和 中等
2401_88085478的博客
06-15 249
节点 0 和节点 1 分别是节点 3 和 2 的孪生节点。链表中只有一对孪生节点，孪生和为 1 + 100000 = 100001。- 节点 0 是节点 3 的孪生节点，孪生和为 4 + 3 = 7。- 节点 1 是节点 2 的孪生节点，孪生和为 2 + 2 = 4。所以，最大孪生和为 max(7, 4) = 7。定义为一个节点和它孪生节点两者值之和。给你一个长度为偶数的链表的头节点。所以，链表的最大孪生和是 6。开始）的孪生节点为第。链表中没有其他孪生节点。
链表算法上篇：LeetCode 206/234/141/142/160/21 题解与易错点
2401_87961121的博客
06-15 626
这篇文章整理链表算法的六道经典题，帮你建立从"能写出来"到"不犯低级错误"的认知闭环。刷链表题最大的坑不是思路，是细节：引用和值傻傻分不清、循环中途空指针、计数差一个……这些错误我都踩过，全记在这里。│ 错误类型 │ 出现题目 │ 根因 ││ 修改 next 前没存 │ 206/234 │ 两变量同一对象 ││ cnt 初始值为 1 │ 234 │ 循环边界差一 ││ 用 == 比较值 │ 234 │ 混淆地址和值比较 ││ 循环中途空指针 │ 141 │ while 只管入口 │。
【leetcode】20.有效的括号js
2402_83244812的博客
06-14 54
本文分享了LeetCode有效的括号问题的两种JavaScript解法。第一种使用栈结构，通过分别处理左右括号进行匹配验证，最后检查栈是否为空。第二种优化解法采用哈希表存储括号对应关系，将左括号对应的右括号压栈，遇到右括号时直接比较栈顶元素，提升代码简洁性和效率。两种方法都遵循栈的特性，确保括号嵌套顺序正确，且最终栈为空才能判定为有效。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 268
LeetCode200 岛屿数量
62. 不同路径
a2606437441的博客
06-12 292
不同路径
LeetCode 3264.K次乘运算后的最终数组I
最新发布
tus00000的博客
06-17 220
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
【leetcode】121.买卖股票的最佳时机js/c++
2402_83244812的博客
06-16 315
摘要：该问题采用贪心算法解决股票买卖最佳时机问题。通过维护当前最小买入价和计算当前卖出利润，更新最大利润值。JavaScript实现遍历数组时动态更新最小价格和最大利润。类似地，C++版本使用迭代器跟踪买入点和遍历卖出点，当发现更低价格时更新买入点，并始终记录最大利润值。两种实现均只需一次遍历，时间复杂度为O(n)。
leetcode3612 用特殊操作处理字符串I
2301_80296866的博客
06-16 45
遍历字符串，按照题目要求进行处理就可。
LeetCode--90.子集II（回溯算法）
Coding...
06-16 228
摘要 该算法解决子集II问题，用于生成包含重复元素数组的所有不重复子集。核心思路是回溯算法配合剪枝策略，通过排序数组和标记使用状态来避免重复子集。具体步骤：1) 对数组排序使相同元素相邻；2) 使用回溯法递归构建子集；3) 通过检查与前一个元素的相等性及使用状态(used数组)来跳过同一层的重复元素。时间复杂度为O(n*2^n)，空间复杂度为O(n)。示例：输入[1,2,2]输出[[],[1],[1,2],[1,2,2],[2],[2,2]]。
【每日一题】LeetCode 148. 排序链表 TypeScript
qq_69682052的博客
06-15 263
1.找出中心节点，分成两段链表。2.将两段链表进行升序排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值