力扣【接雨水问题】 leetcode-42：暴力-备忘录-双指针三种方法

题目描述：

思路：

不要去思考整体装多少，应该去思考局部的；
去想每一个 i 的位置，最多能够装多少雨水；

这里的 i 位置最多可以装 2 雨水；
核心就是：每一个 i 位置的雨水量，都 和 i 位置 左边最高的柱子，右边最高的柱子有关。
需要知道 i 位置左边所有的柱子最高的，以及 i 位置 右边所有的柱子最高的，然后 取得一个 Min。 毕竟装雨水多少，是由最矮的那一个去决定的！
所以，题目的难题就在于，怎么获取 l_max and r_max,在获取的方式上面去一步一步优化。

大致框架：
water[i] = min(max(left) , max(right)) - height[i];

解法一：暴力法：

时间复杂度 O(N^2)，空间复杂度 O(1)。

class Solution {
public:
    int trap(vector<int>& height) {
    //1、暴力法 O(n^2) 我们不要想整体，而应该去想局部
    //具体来说，仅仅对于位置i，能装下多少水呢？
    int n= height.size();
    int res = 0;
    for (int i =0 ; i < n - 1; i++) {
        int l_max = 0; int r_max = 0;
        //找左右两边最高的比较 min 减去自己 就是单独自己的装最多的
        for (int j = i; j < n; j++) {
            r_max = max(r_max,height[j]);
        }
        for (int j = i; j >= 0; j--) {
            l_max = max(l_max,height[j]);
        }
        res += min(l_max,r_max) - height[i];
    }
    return res;
    }
};

一顿操作猛如虎
一看结果百分五~
执行结果：

解法二，备忘录算法

其实是上面暴力法的一个优化，暴力法是到了每一个位置，都要计算这个位置的 l_max 和 r_max；备忘录算法只是预先算好了，放在一个数组里面；
所以备忘录算法时间复杂度降低为 O(N)，但是空间复杂度是 O(N)。

class Solution {
public:
    int trap(vector<int>& height) {
    //2、备忘录优化为 O(n);提前算好每一个位置 左右最高和最低的
    if (height.empty()) return 0;
    int n = height.size();
    int res = 0;
    vector<int> l_max(n), r_max(n);
    l_max[0] = height[0];
    r_max[n - 1] = height[n - 1];
    for (int i = 1; i < n; i++) {
        l_max[i] = max(height[i],l_max[i - 1]) ;
    }
    for (int i = n -2; i >= 0; i--) {
        r_max[i] = max(height[i],r_max[i + 1]) ;
    }
    for (int i = 1; i< n - 1; i++) {
        res += min(l_max[i],r_max[i]) - height[i];
    }  
    return res;  
    }
};

执行结果：

解法三：双指针

双指针边走边算，节约空间复杂度

class Solution {
public:
    int trap(vector<int>& height) {

    //3、双指针解法
    if (height.empty()) return 0;
    int n = height.size();
    int res = 0;
    int left = 0;
    int right = n - 1;

    int l_max = height[0];
    int r_max = height[n - 1];
    while (left <= right) {
        l_max =max(l_max,height[left]);
        r_max =max(r_max,height[right]);

        if (l_max < r_max) {
            res += l_max - height[left];
            left ++;
        } else {
            res += r_max - height[right];
            right --;
        }
    }
    return res;
    }
};

执行结果：