【leetcode-双指针】接雨水/盛水最多的容器

给定 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

动态规划

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        if (height == null || len == 0)
            return 0;

        int sum = 0;
        int[] left_max = new int[len];
        int[] right_max = new int[len];
        left_max[0] = height[0];
        for (int i = 1; i < len; i++)
            left_max[i] = Math.max(height[i], left_max[i - 1]);
        
        right_max[len - 1] = height[len - 1];
        for (int i = len - 2; i >= 0; i--)
            right_max[i] = Math.max(height[i], right_max[i + 1]);

        for (int i = 1; i < len - 1; i++)
            sum += Math.min(left_max[i], right_max[i]) - height[i];
        return sum;
    }
}

辅助栈法

用栈来跟踪可能储水的最长的条形块。

class Solution {
    public int trap(int[] height) {
        int sum = 0, cur_idx = 0, len = height.length;
        Deque<Integer> stack = new LinkedList<Integer>();
        while (cur_idx < len) {
            while (!stack.isEmpty() && height[cur_idx] > height[stack.peek()]) {
                int top = stack.pop();
                if (stack.isEmpty())
                    break;
                int distance = cur_idx - stack.peek() - 1;
                int bounded_height = Math.min(height[cur_idx], height[stack.peek()]) - height[top];
                sum += distance * bounded_height;
            }
            stack.push(cur_idx++);
        }
        return sum;
    }
}

双指针法

class Solution {
    public int trap(int[] height) {
        int len = height.length;
        int sum = 0;
        int left = 0, right = len - 1;
        int left_max = 0, right_max = 0;
        while (left < right) {
            if (height[left] < height[right]) {
                if (height[left] >= left_max) {
                    left_max = height[left];
                } else {
                    sum += (left_max - height[left]);
                }
                ++left;
            } else {
                if (height[right] >= right_max) {
                    right_max = height[right];
                } else {
                    sum += (right_max - height[right]);
                }
                --right;
            }
        }
        return sum;
    }
}

盛水最多的容器

给你 n 个非负整数 $a_1，a_2，...，a_n$，每个数代表坐标中的一个点 $(i,a_i)$。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 $(i,a_i)$和 $(i,0)$ 。找出其中的两条线，使得它们与 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

示例 3：
输入：height = [4,3,2,1,4]
输出：16

示例 4：
输入：height = [1,2,1]
输出：2

暴力遍历

class Solution {
    public int maxArea(int[] height) {
        int n = height.length;
        int max = 0;
        for (int i = 0; i < n; ++i) {
            if (height[i] == 0) {
                continue;
            }
            int skip = Math.max(max / height[i], 1); // 跳过面积比当前最大值小的值
            for (int j = i + skip; j < n; ++j) {
                int capacity = Math.min(height[i], height[j]) * (j - i);
                max = Math.max(max, capacity);
            }
        }
        return max;
    }
}

双指针法

水槽的实际高度由两板中的短板决定。若向内移动短板，水槽的短板可能变大，因此水槽面积可能增大；若向内移动长板，水槽的短板不变或变小，下个水槽的面积一定小于当前水槽面积。

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