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;
}
