C++刷题笔记(45)——leetcode42、84

题目1：42.接雨水

双指针法

用双指针法首先要确定是按行计算、还是按列计算。

如果按列计算，那么只需要求出每一列雨水的高度，
每一列雨水的高度取决于当前列的高度、左边最高的列和右边最高的列中较矮的列的高度

class Solution {
public:
    int trap(vector<int>& height) {
        int sum = 0;                                           //雨水体积
        for (int i = 0; i < height.size(); i++) {
            if (i == 0 || i == height.size() - 1) continue;    //第一列和最后一列不接雨水
            int lheight = height[i], rheight = height[i];      //记录左右列的最高高度
            for (int l = i - 1; l >= 0; l--) {                 //求左边最高列
                if (height[l] > lheight) lheight = height[l];
            }
            for (int r = i + 1; r < height.size(); r++) {      //求右边最高列
                if (height[r] > rheight) rheight = height[r];
            }
            int h = min(lheight, rheight) - height[i];         //计算该列的雨水高度
            if (h > 0) sum += h;                               //只有h>0才计算到雨水体积中
        }
        return sum;
    }
};

动态规划

在双指针中为了得到某一列两边的最高高度，使用双指针各遍历两边

也可以把每一个位置的左边最高高度记录在一个数组上（maxleft），右边最高高度记录在一个数组上（maxright），避免重复计算

当前位置，左边的最高高度是前一个位置的左边最高高度和本高度的最大值：
即从左向右遍历：maxleft[i] = max(height[i], maxleft[i - 1]);
同理从右向左遍历：maxright[i] = max(height[i], maxright[i + 1]);

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;
        vector<int> maxleft(height.size(), 0);
        vector<int> maxright(height.size(), 0);
        int size = height.size();     
        maxleft[0] = height[0];                  //记录左边柱子最大高度
        for (int i = 1; i < size; i++) {
            maxleft[i] = max(height[i], maxleft[i - 1]);
        }
        maxright[size - 1] = height[size - 1];   //记录右边柱子最大高度
        for (int i = size - 2; i >= 0; i--) {
            maxright[i] = max(height[i], maxright[i + 1]);
        }
        int sum = 0;
        for (int i = 0; i < size; i++) {
            int h = min(maxleft[i], maxright[i]) - height[i];
            if (h > 0) sum += h;
        }
        return sum;
    }
};

单调栈

单调栈是按行计算雨水，存储的是每一列高度对应的下标，从栈顶到栈底呈递增顺序，因为如果要添加的列高大于栈顶元素对应的列高，说明出现凹槽，栈顶元素对应的列即为凹槽底部，栈顶第二个元素对应的列为左边的列，要添加的元素为右边的列。

对于更低的柱子：
如果能找到高柱子，这里就能接到雨水，所以入栈把它保存起来

对于相同高度的柱子：
相同高度的柱子，相当于出现了新的左边列，在计算的时候是用的新的左边列，因此将栈顶元素(旧下标)出栈，将新的左边列对应的下标入栈

对于更高的柱子：
说明出现了凹槽，此时就可以计算接了多少雨水
此时栈顶元素就是凹槽的底部，下标记为mid，对应高度为height[mid]，然后将栈顶元素弹出；
此时栈顶元素就是凹槽左边柱子，下标为st.top()，对应高度为height[st.top()]；
当前遍历的元素i就是凹槽右边柱子，下标为i，对应高度为height[i]；
其实就是栈顶、栈顶的下一个元素、要入栈的三个元素来接水，
那么雨水高度是min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，即int h = min(height[st.top()], height[i]) - height[mid]
雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），即int w = i - st.top() - 1

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;
        stack<int> st;       // 存储下标，计算的时候用下标对应的柱子高度
        st.push(0);
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            if (height[i] < height[st.top()]) {     //遍历到的高度 小于 栈顶元素对应的高度
                st.push(i);
            } if (height[i] == height[st.top()]) {  //遍历到的高度 等于 栈顶元素对应的高度
                st.pop(); // 其实这一句可以不加，效果是一样的，主要在于处理的思路
                st.push(i);
            }
            else {                                  //遍历到的高度 大于 栈顶元素对应的高度
                while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int h = min(height[st.top()], height[i]) - height[mid];
                        int w = i - st.top() - 1; // 注意减一，只求中间宽度
                        sum += h * w;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};

代码精简后：

class Solution {
public:
    int trap(vector<int>& height) {
        stack<int> st;
        st.push(0); 
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            while (!st.empty() && height[i] > height[st.top()]) {
                int mid = st.top();
                st.pop();
                if (!st.empty()) {
                    int h = min(height[st.top()], height[i]) - height[mid];
                    int w = i - st.top() - 1;
                    sum += h * w;
                }
            }
            st.push(i);
        }
        return sum;
    }
};

题目2：84.柱状图中最大的矩形

接雨水是找每个柱子左右两边第一个大于该柱子高度的柱子
本题是找每个柱子左右两边第一个小于该柱子的柱子，因此单调栈从栈顶到栈底呈递减顺序

只有栈里从大到小的顺序，才能保证栈顶元素找到左右两边第一个小于栈顶元素的柱子

如果遍历到的元素 大于 栈顶元素对应的高度，则直接入栈

如果遍历到的元素 等于 栈顶元素对应的高度，此时相当于出现了新的左边柱子，因此将栈顶元素(旧下标)出栈，将新的左边列对应的下标入栈

如果遍历到的元素 小于 栈顶元素对应的高度，此时就找到了一个矩形，计算此时矩形的面积。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {  //和接雨水的代码结构差不多
        stack<int> st;
        heights.insert(heights.begin(), 0); //数组头部加入元素0
        heights.push_back(0);               //数组尾部加入元素0
        st.push(0);
        int result = 0;
        // 第一个元素已经入栈，从下标1开始
        for (int i = 1; i < heights.size(); i++) {
            if (heights[i] > heights[st.top()]) {
                st.push(i);
            }
            else if (heights[i] == heights[st.top()]) {
                st.pop();     //可以不加，效果一样，思路不同
                st.push(i);
            }
            else {
                while (heights[i] < heights[st.top()]) {
                    int mid = st.top();
                    st.pop();
                    int left = st.top();
                    int right = i;
                    int w = right - left - 1;
                    int h = heights[mid];
                    result = max(result, w * h);
                }
                st.push(i);
            }
        }
        return result;
    }
};

整体代码结构和接雨水差不多，但是在数组的头尾加了0：

如果遍历之后，栈不为空，那么还需要一步：即弹出栈中所有元素，分别计算最大面积。然而当加了两个0以后，在结束后，栈一定为空
即因为0入栈的时候，会把前面所有的数全部弹出，如果0最后一个入栈，所有的数都会弹出

代码化简后：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0); // 数组尾部加入元素0
        st.push(0);
        int result = 0;
        for (int i = 1; i < heights.size(); i++) {
            while (heights[i] < heights[st.top()]) {
                int mid = st.top();
                st.pop();
                int w = i - st.top() - 1;
                int h = heights[mid];
                result = max(result, w * h);
            }
            st.push(i);
        }
        return result;
    }
};