bzoj 2936 [Poi 1999] 降水 - 并查集

题目传送门

　　需要root权限的传送门

题目大意

　　有一个$n\times m$的网格图，每一格都有一个高度。一次降雨过后问最多能积多少水。

　　考虑算每一高度能储存的水的量。

　　如果小于等于这个高度的格子和边界连通，那么水就会流走，这一部分不能算入答案。

　　所以用并查集维护高度小于等于当前高度的格子的连通性。每次答案加已经找到的格子数目减去和边界连通的格子数。

　　时间复杂度$O(nm + V)$。（用真·并查集就是这样）

　　网上咋一群带个log的做法。想去loj出个加强版。

Code

 /**
  * bzoj
  * Problem#2936
  * Accepted
  * Time: 56ms
  * Memory: 1688k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 const int N = , V = ;
 const int mov[][] = {{, }, {, }, {, -}, {-, }};

 typedef class Dsu {
     public:
         int *f;
         int *siz;

         Dsu() {    }
         Dsu(int n) {
             f = new int[(n + )];
             siz = new int[(n + )];
             f[] = siz[] = ;
             for (int i = ; i <= n; i++)
                 f[i] = i;
             for (int i = ; i <= n; i++)
                 siz[i] = ;
         }

         int find(int x) {
             return (f[x] == x) ? (x) :(f[x] = find(f[x]));
         }

         void unit(int x, int y) {
             int fx = find(x);
             int fy = find(y);
             if (fx == fy)
                 return;
             siz[fy] += siz[fx];
             f[fx] = fy;
         }
 }Dsu;

 int n, m;
 Dsu uf;
 boolean found[N][N];
 vector< pair<int, int> > vs[V + ];

 int id(int x, int y) {
     if (!x || !y || x == n +  || y == m + )
         return ;
     return (x - ) * m + y;
 }

 inline void init() {
     scanf("%d%d", &n, &m);
     uf = Dsu(n * m);
     for (int i = ; i <= n; i++)
         for (int j = , h; j <= m; j++) {
             scanf("%d", &h);
             vs[h].push_back(pair<int, int>(i, j));
         }
 }

 int cfound = , res = ;
 inline void solve() {
     int all = n * m;
     for (int v = ; v <= V && uf.siz[uf.find()] != all; v++) {
         for (int j = ; j < (signed) vs[v].size(); j++) {
             int x = vs[v][j].first, y = vs[v][j].second;
             found[x][y] = true, cfound++;
             for (int k = ; k < ; k++) {
                 int nx = x + mov[k][], ny = y + mov[k][], nxid = id(nx, ny);
                 if (!nxid || found[nx][ny])
                     uf.unit(nxid, id(x, y));
             }
         }
         res += cfound - uf.siz[uf.find()];
     }
     printf("%d", res);
 }

 int main() {
     init();
     solve();
     return ;
 }