代码随想录训练营第59天|LeetCode 503.下一个更大元素II、42. 接雨水

参考

代码随想录

题目一：LeetCode 503.下一个更大元素II

这个题在496. 下一个更大元素 I基础上数组变成了环，其实两次两次数组就可以了。代码如下：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(), -1);
        stack<int> stk;
        for(int i = 0; i < 2 * nums.size(); i++){
            int j = i % nums.size();
            while(!stk.empty() && nums[stk.top()] < nums[j]){
                result[stk.top()] = nums[j];
                stk.pop();
            }
            stk.push(j);
        }
        return result;
    }
};

题目二：LeetCode 42. 接雨水

双指针法

按照列来计算，每列的宽度是1，因此将问题转化为求每一列的高度就可以了。

每一列的高度等于其左边最高柱子和右边最高柱子中的较小值，如下图所示：

图中阴影柱子的高度就是两个红色柱子中高度较小的那个，即图中左边的红色柱子，再减去自身的高度就得到了雨水的体积。因此，对于每个柱子，要找到其左边和右边的最高柱子。代码实现如下：

class Solution {
public:
    int trap(vector<int>& height) {
        int result = 0;
        for(int i = 0; i < height.size(); i++){
            int r_height = height[i];   //左边最高的柱子高度
            int l_height = height[i];   //右边最高的柱子高度
            for(int j = i-1; j >=0; j --)
                if(height[j] > l_height)    l_height = height[j];
            for(int j = i + 1; j < height.size(); j++)
                if(height[j] > r_height)    r_height = height[j];
            result += min(l_height,r_height) - height[i];
        }
        return result;
    }
};

上面的代码提交之后会有两个测试用例超时，其他能通过。

动态规划

由上面的双指针可以看出，在每个位置需要知道其左边和右边的最高柱子，在动态规划中，用dp数组来记录两边的最高柱子。

1. 确定dp数组下标及其含义
   dp[i][0]：第i个柱子左边的最高柱子高度为dp[i][0].
   dp[i][1]：第i个柱子右边的最高柱子的高度为dp[i][1].

2. 确定递推公式
   递推公式如下：

dp[i][0] = max(dp[i-1][0],height[i]);
dp[i][1] = max(dp[i+1][1],height[i]);

3. 初始化dp数组

dp[0][0] = height[0];
dp.back()[1] = height.back();

4. 确定遍历顺序
   对于dp[i][0]，要从小到大遍历；
   对于dp[i][1]，要从大到小遍历。

5. 举例推导dp数组
   
   完整的代码实现如下：

class Solution {
public:
    int trap(vector<int>& height) {
        vector<vector<int>> dp(height.size(), vector<int>(2));
        int result = 0;
        dp[0][0] = height[0];
        dp.back()[1] = height.back();
        //求dp数组
        for(int i = 1; i < height.size(); i++)
            dp[i][0] = max(dp[i-1][0],height[i]);
        for(int i = height.size() - 2; i >= 0; i--)
            dp[i][1] = max(dp[i+1][1],height[i]);
        //求体积
        for(int i = 0; i < dp.size(); i++){
            result += min(dp[i][0],dp[i][1]) - height[i];
        }
        return result;
    }
};

单调栈

在单调栈解法中，要按照行来计算，如下图所示：

栈内的元素从栈顶到栈底递增，即栈顶元素是最小的，当前元素数值和栈顶元素数值存在下面的三种可能：

• 当前元素大于栈顶元素，此时可以弹出栈顶元素计算雨水的体积了，如下图所示。弹出栈顶元素左为容器的“底”，当前的元素和新的栈顶元素构成容器的边，计算完成之后，再次比较当前元素和栈顶元素，重复上面的操作，知道当前元素小于栈顶元素或者栈中只有一个元素。注意，实际代码中栈里保存的是元素的下标。
  

• 当前元素等于栈顶元素，直接将新的元素的下标入栈，因为我们需要用最右边的柱子来计算，如下图所示。入栈之前可以不弹栈，但是当前的元素必须入栈。栈中有两个相同高度的柱子，只能重复计算一次，不会导致错误。
  

• 当前元素小于栈顶元素，则直接将当前元素入栈。

再次强调，实际代码中栈里保存的是元素下标，因为需要用下标来计算宽度。

代码实现如下：

class Solution {
public:
    int trap(vector<int>& height) {
        int result = 0;
        stack<int> stk;
        for(int i = 0; i < height.size(); i++){
            while(!stk.empty() && height[i] >= height[stk.top()]){
                int tmp = stk.top();
                stk.pop();
                if(!stk.empty()){   //至少要三个柱子
                    int w = i - stk.top() - 1;  //宽
                    int h = min(height[i],height[stk.top()]) - height[tmp]; //高
                    result += w * h;
                }
            }
            stk.push(i);
        }
        return result;
    }
};