總結（1）蓄水類問題：11. 盛最多水的容器、42. 接雨水、407. 接雨水 II、（補充：優先隊列實現存儲結構體的大小根堆）

1 用優先級隊列實現存儲結構體的大小根堆

自我認爲有這個基本上滿足算法問題中關於大小根堆的使用了。
在之前我們寫過一篇博客實際應用中我們《藉助於數組vector來建堆https://blog.csdn.net/weixin_41747893/article/details/106087209》。但是並沒有滿足實際應用，經常我們大小根堆裏面放的並不是僅僅只有一個數或字符，可能放一個結構體，那麼實現如下：
（1）建立小根堆

struct Node {
	int row;
	int col;
	int val;
	Node(int _r, int _c, int _v) :row(_r), col(_c), val(_v) {}//方便於我們插入
	bool operator<(const Node& dir)const {
		return val > dir.val;//我們以val值爲鍵值進行建堆。自己可以定義
	}
};
priority_queue<Node>minq;
minq.push({ 1,2,3 });

（2）建立大根堆

struct Nodebig {////建立大根堆
	int R;
	int C;
	int V;
	Nodebig(int r,int c,int v):R(r),C(c),V(v){}
	bool operator<(const Nodebig& dir)const {
		return V < dir.V;////我們以val值爲鍵值進行建堆。自己可以定義
	}
};
priority_queue<Nodebig>bigq;
bigq.push({1,2,3});

接下來我們看題

2 11. 盛最多水的容器

給你 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

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/container-with-most-water
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

關於這個題簡單，我們從數組的左右兩端（left,right）開始給數組裏面走，記錄存儲水量最大的值：
（1）當left端低於right端時，將left右移一位，選取左右高度最小的計算需水量（最小值*（右下標-左下標））；
（2）當right端低於left端時，將right左移一位，選取左右高度最小的計算需水量（最小值*（右下標-左下標））；

代碼如下

class Solution {
public:
	int maxArea(vector<int>& height) {
		if (height.empty())return 0;

		int l = 0;
		int r = height.size() - 1;
		int maxres = min(height[l], height[r]) * (r - l);
		while (l < r) {
			if (height[l] <= height[r]){
				l++;
				maxres = max(maxres, min(height[l], height[r]) * (r - l));
			}
			else {
				r--;
				maxres = max(maxres, min(height[l], height[r]) * (r - l));
			}
		}
		return maxres;
	}
};

3 42. 接雨水

給定 n 個非負整數表示每個寬度爲 1 的柱子的高度圖，計算按此排列的柱子，下雨之後能接多少雨水。

上面是由數組 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度圖，在這種情況下，可以接 6 個單位的雨水（藍色部分表示雨水）。 感謝 Marcos 貢獻此圖。

示例:

輸入: [0,1,0,2,1,0,1,3,2,1,2,1]
輸出: 6

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/trapping-rain-water
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

從左右邊界出發，找最小邊界然後緊挨着最小邊界給裏面搜索：
當小邊界緊挨着的高度大於等於小邊界時，存水量爲0，更新這個小邊界；
當小邊界緊挨着的高度小於小邊界時，存水量爲緊挨的高度-小邊界。
代碼如下：

class Solution {
public:
	int trap(vector<int>& height) {
		if (height.size() <= 1)return 0;
		int rightV = height[height.size() - 1];
		int leftV = height[0];
		int l = 0, r = height.size() - 1;
		int res = 0;
		while (l<r) {
			if (rightV >= leftV) {
				res += max(0, leftV - height[l]);
				leftV = max(leftV, height[++l]);
			}
			if (rightV < leftV) {
				res += max(0, rightV - height[r]);
				rightV = max(rightV, height[--r]);
			}
		}
		return res;
	}
};

4 407. 接雨水 II

給你一個 m x n 的矩陣，其中的值均爲非負整數，代表二維高度圖每個單元的高度，請計算圖中形狀最多能接多少體積的雨水。
示例：
給出如下 3x6 的高度圖:
[
[1,4,3,1,3,2],
[3,2,1,3,2,4],
[2,3,3,2,3,1]
]

返回 4 。

如上圖所示，這是下雨前的高度圖[[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]] 的狀態。

下雨後，雨水將會被存儲在這些方塊中。總的接雨水量是4。
提示：

1 <= m, n <= 110
0 <= heightMap[i][j] <= 20000

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/trapping-rain-water-ii
著作權歸領釦網絡所有。商業轉載請聯繫官方授權，非商業轉載請註明出處。

思路：
這個題是對上一個題的擴展，上一個題是一維數組，只有左右邊界，因此我們申請了幾個變量，然後對比變量找出最小邊界進行搜索；
這個題是一個二維數組，邊界會更多，因此我們借用一個優先隊列，
（1）將隊列設置爲小根堆，將所有邊界值存入隊列中，每次從隊列中最小的值進行搜索。在隊列中每個元素存儲有二維數組點A的橫縱座標和點A的高度。
（2）取邊界最小的作爲可接雨水的最高位置curmax，並將該點彈出隊列，開始給裏面進行搜索。
（3）當curmax 緊鄰位置的高度cur大於等於curmax時,存水量爲0,更新curmax，並將該點壓入隊列；
（4）當curmax緊鄰位置的高度cur小於curmax時，存水量爲cur-curmax，並將該點壓入隊列。
注意：
1》此處緊鄰位置是上下左右，四個方位，並且該位置未被搜索過。
2》不能搜索已經搜索過的位置，因此設置一個tag標籤數組，當該處被搜索過，則置爲1，未搜素置爲0.

代碼如下：

class Solution {
public:
    struct Node {
        int row;
        int col;
        int val;
        Node(int _r, int _c, int _v) :row(_r), col(_c), val(_v) {}
        bool operator<(const Node& dir)const {
            return val > dir.val;
        }
    };
	int trapRainWater(vector<vector<int>>& heightMap) {
		if (heightMap.empty() || heightMap.size() <= 1 || heightMap[0].size() <= 1)return 0;
		int h_r = heightMap.size(), h_c = heightMap[0].size();
		vector<vector<int>>tag(h_r, vector<int>(h_c,0));//標記每次該座標是否被計算過。
		int res = 0;
		priority_queue<Node>myq;//小根堆
		////邊界入堆
		for (int i = 0; i < h_c; i++) {//第一行
			myq.push({ 0,i,heightMap[0][i] });
			tag[0][i] = 1;
		}
		for (int i = 1; i < h_r; i++) {//第一列
			myq.push({ i,0,heightMap[i][0] });
			tag[i][0] = 1;
		}
		for (int i = 1; i < h_r; i++) {//最後一列
			myq.push({ i,h_c-1,heightMap[i][h_c - 1] });
			tag[i][h_c - 1] = 1;
		}
		for (int i = 1; i < h_c-1; i++) {//最後一行
			myq.push({ h_r-1,i,heightMap[h_r - 1][i] });
			tag[h_r - 1][i] = 1;
		}
		int maxcur = 0;
		while (!myq.empty()) {
			Node cur = myq.top();
			myq.pop();
			maxcur = max(maxcur, cur.val);
			int cur_r = cur.row;
			int cur_c = cur.col;
			if (cur_r > 0 && !tag[cur_r - 1][cur_c]) {
				res += max(0, maxcur - heightMap[cur_r - 1][cur_c]);
				myq.push({ cur_r - 1,cur_c, heightMap[cur_r - 1][cur_c] });
				tag[cur_r - 1][cur_c] = 1;
			}
			if (cur_r < h_r-1 && !tag[cur_r + 1][cur_c]) {
				res += max(0, maxcur - heightMap[cur_r + 1][cur_c]);
				myq.push({ cur_r + 1,cur_c, heightMap[cur_r + 1][cur_c] });
				tag[cur_r + 1][cur_c] = 1;
			}
			if (cur_c > 0 && !tag[cur_r ][cur_c-1]) {
				res += max(0, maxcur - heightMap[cur_r][cur_c-1]);
				myq.push({ cur_r ,cur_c - 1, heightMap[cur_r][cur_c-1] });
				tag[cur_r ][cur_c - 1] = 1;
			}
			if (cur_c < h_c-1 && !tag[cur_r][cur_c + 1]) {
				res += max(0, maxcur - heightMap[cur_r][cur_c + 1]);
				myq.push({ cur_r ,cur_c + 1, heightMap[cur_r][cur_c + 1] });
				tag[cur_r][cur_c + 1] = 1;
			}
		}
		return res;
	}
};

測試

int main() {
	Solution S;
	vector<vector<int>>arr = { {1,4,3,1,3,2} , {3,2,1,3,2,4},{2,3,3,2,3,1} };
	cout << S.trapRainWater(arr) << endl;
}