AcWing 592. 雨

题目描述：
海里有一个小岛。

岛可以描述为一个具有 R 行 C 列的矩阵，其中包含的数字 H[i][j] 表示每个单元格的高度。

以下是一个 3×3 岛屿的示例：

3 5 5
5 4 5
5 5 5
有时，大雨会在这个岛上的每个单元格上均匀地降落。

你可以假设降水量可以是无限大。

在这样的大雨之后，岛上的一些区域（由沿着边缘连接的一个或多个单元格形成）可能会存在积水。

一片区域可以存在积水的前提是与该区域内单元格沿着边缘连接的区域外的单元格的高度均高于区域内单元格。（周围的海洋被视为高度为 0 的无限单元格。）

否则，水将始终流入其他区域并最终出海。

你可以假设海的高度永远不会改变。

在大雨过后，我们将使用 W[i][j] 来表示岛屿上每个单元格的高度。

以下是对大雨过后的示例岛屿的高度的分析。

最中央的初始高度为 4 的单元格被初始高度为 5 的单元格包围着，因此在该单元格将产生积水，在积水高度到达 5 以后，没有更多区域被高度更高的单元格包围，因此将不再继续积水。

请注意，水不会直接在两个共享顶点的单元格之间流动;水必须沿着共同的边缘流动。（所以中央单元格的积水不会从左上角处流走）

以下是雨后示例岛屿的高度：

3 5 5
5 5 5
5 5 5
给定岛的高度矩阵，你能计算出大雨后的每个单元格的增加高度（W[i][j]−H[i][j]）的总和吗？

输入格式
第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含两个整数 R 和 C。

接下来 R 行每行包含 C 个整数 H[i][j]，表示矩阵内单元格的高度。

输出格式
每组数据输出一个结果，每个结果占一行。

结果表示为 Case #x: y，其中 x 是组别编号（从 1 开始），y 是增加高度的总和。

数据范围
1≤T≤100,
1≤H[i][j]≤1000,
1≤R,C≤50
输入样例：

3
3 3
3 5 5
5 4 5
5 5 5
4 4
5 5 5 1
5 1 1 5
5 1 5 5
5 2 5 8
4 3
2 2 2
2 1 2
2 1 2
2 1 2

输出样例：

Case #1: 1
Case #2: 3
Case #3: 0

样例解释
样例#1已经在题目中说明。

在样例#2中，雨后岛屿看起来像这样：

5 5 5 1
5 2 2 5
5 2 5 5
5 2 5 8
样例#3在雨后保持不变。
思路：
对于每个点雨后的积水深度，等于大海到这个点经过高度最小点的路径上的高度最大格子的值。
即最短路上的最大值。
why？
因为积水的深度取决于最短路上最高的高度。
比方说一个水库的储水深度一定是大坝的高度，那么这个大坝所在的河流就是水库流向大海的最短路，其中大坝为最短路上的最大值。

有一个细节就是优先队列在写排序函数的时候需要反着写，而sort需要正着写。
代码写的有点长冗余比较多
代码：

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
struct Node
{
    int x,y,w;
    friend bool operator<(Node a, Node b)
    {
        if(a.w>b.w)
        {
            return true;
        }
        return false;
    }
};
const int N=1e3+10;
int g[N][N];
bool st[N][N];
int dist[N][N];
int dx[4]={0,0,1,-1},dy[]={1,-1,0,0};
int main()
{
    int T;
    cin>>T;
    for(int k=1;k<=T;k++)
    {
        int n,m;
        cin>>n>>m;
        memset(dist,-1,sizeof dist);
        memset(st,false,sizeof st);
        priority_queue<Node>q;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                cin>>g[i][j];    
            }
        }
        for(int i=2;i<n;i++)
        {
            dist[i][1]=g[i][1];
            dist[i][m]=g[i][m];
            st[i][1]=true;
            st[i][m]=true;
            q.push({i,1,g[i][1]});
            q.push({i,m,g[i][m]});
        }
        for(int i=2;i<m;i++)
        {
            dist[1][i]=g[1][i];
            dist[n][i]=g[n][i];
            st[1][i]=true;
            st[n][i]=true;
            q.push({1,i,g[1][i]});
            q.push({n,i,g[n][i]});
        }
        st[1][1]=true;
        st[n][m]=true;
        st[1][m]=true;
        st[n][1]=true;
        int res=0;
        while(!q.empty())
        {
            Node t=q.top();
            q.pop();
            int x=t.x;
            int y=t.y;
            for(int i=0;i<4;i++)
            {
                int a=x+dx[i];
                int b=y+dy[i];
                if(a<1 || a>n || b<1 || b>m)
                {
                    continue;
                }
                if(st[a][b])
                {
                    continue;
                }
                if(dist[a][b]<max(t.w,g[a][b]))
                {
                    dist[a][b]=max(t.w,g[a][b]);
                    res+=dist[a][b]-g[a][b];
                    st[a][b]=true;
                    q.push({a,b,dist[a][b]});
                }
            }
        }
        printf("Case #%d: %d\n", k, res);
    }
}