bzoj 2936 [Poi 1999] 降水

题目传送门

　　需要root权限的传送门

题目大意

　　有一个$n imes 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 = 105, V = 10000;
const int mov[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

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

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

        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 + 1];

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

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

int cfound = 0, res = 0;
inline void solve() {
    int all = n * m;
    for (int v = 1; v <= V && uf.siz[uf.find(0)] != all; v++) {
        for (int j = 0; 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 = 0; k < 4; k++) {
                int nx = x + mov[k][0], ny = y + mov[k][1], nxid = id(nx, ny);
                if (!nxid || found[nx][ny])
                    uf.unit(nxid, id(x, y));
            }
        }
        res += cfound - uf.siz[uf.find(0)];
    }
    printf("%d", res);
}

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