zoj 3859 DoIt is Being Flooded (MFSet && Flood Fill)

ZOJ :: Problems :: Show Problem

　　这题开始的时候想不到怎么调整每个grid的实际淹没时间，于是只好找了下watashi的题解，发现这个操作还是挺简单的。

ZOJ3354 | ゆっくりでいいさ debug这题累死了。。解释还是移步看watashi大神的吧。。

　　除了开始的时候这个调整，后面并查集的部分是相当容易想到的，其实就是用并查集了统计每一个块的个数。

代码如下：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <map>
 #include <queue>

 using namespace std;

 int n, m;
 inline int con(int x, int y) { return x * m + y;}
 inline bool inmat(int x, int y) { return  <= x && x < n &&  <= y && y < m;}

 const int dx[] = { , -, , };
 const int dy[] = { -, , , };
 const int N = ;
 const int M = N * N;

 struct MFS {
     int fa[M], cnt[M];
     int fx, fy;
     void init() { for (int i = ; i < M; i++) fa[i] = i, cnt[i] = ;}
     int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]);}
     void merge(int x, int y) {
         fx = find(x), fy = find(y);
         if (fx == fy) return ;
         fa[fy] = fx;
         cnt[fx] += cnt[fy];
     }
     bool same(int x, int y) { return find(x) == find(y);}
     int count(int x) { return cnt[find(x)];}
 } mfs;
 bool vis[N][N];
 int qry[][], hmk[];

 struct Grid {
     int h, x, y;
     Grid() {}
     Grid(int h, int x, int y) : h(h), x(x), y(y) {}
     bool operator < (Grid a) const { return h > a.h;}
 } grid[M];

 int mat[N][N];
 map<int, int> id;
 map<int, int> cur, rec[];
 priority_queue<Grid> pq;

 int bitcnt(int x) {
     int ret = ;
     for (int i = ; i < ; i++) if (x &  << i) ret++;
     return ret;
 }

 int main() {
 //    freopen("in", "r", stdin);
 //    freopen("out", "w", stdout);
     int matsz, t;
     int cx, cy, nx, ny;
     while (~scanf("%d%d", &n, &m)) {
         matsz = n * m, t = ;
         while (!pq.empty()) pq.pop();
         memset(vis, , sizeof(vis));
         for (int i = ; i < n; i++) for (int j = ; j < m; j++) {
             scanf("%d", &mat[i][j]);
             if (i ==  || j ==  || i == n -  || j == m - ) {
                 grid[t] = Grid(mat[i][j], i, j);
                 pq.push(grid[t]);
                 t++;
                 vis[i][j] = true;
             }
         }
         while (!pq.empty()) {
             cx = pq.top().x, cy = pq.top().y;
             pq.pop();
             for (int i = ; i < ; i++) {
                 nx = cx + dx[i];
                 ny = cy + dy[i];
                 if (inmat(nx, ny)) {
                     if (vis[nx][ny]) continue;
                     mat[nx][ny] = max(mat[nx][ny], mat[cx][cy]);
                     grid[t] = Grid(mat[nx][ny], nx, ny);
                     pq.push(grid[t]);
                     t++;
                     vis[nx][ny] = true;
                 }
             }
         }
         sort(grid, grid + matsz);
         int k;
         scanf("%d", &k);
         for (int i = ; i < k; i++) {
             for (int j = ; j < ; j++) scanf("%d", &qry[i][j]);
             hmk[i] = qry[i][];
         }
         sort(hmk, hmk + k);
         int sz = unique(hmk, hmk + k) - hmk;
         reverse(hmk, hmk + sz);
         id.clear();
         cur.clear();
         memset(vis, , sizeof(vis));
         mfs.init();
         for (int i = , c = , a, b; i < sz; i++) {
             id[hmk[i]] = i;
             while (c < matsz && grid[c].h > hmk[i]) {
                 cx = grid[c].x, cy = grid[c].y;
                 vis[cx][cy] = true;
                 cur[]++;
                 for (int d = ; d < ; d++) {
                     nx = cx + dx[d], ny = cy + dy[d];
                     if (!inmat(nx, ny) || !vis[nx][ny]) continue;
                     a = con(cx, cy), b = con(nx, ny);
                     if (!mfs.same(a, b)) {
                         int ca = mfs.count(a);
                         int cb = mfs.count(b);
                         cur[ca]--;
                         if (cur[ca] == ) cur.erase(ca);
                         cur[cb]--;
                         if (cur[cb] == ) cur.erase(cb);
                         mfs.merge(a, b);
                         cur[mfs.count(a)]++;
                     }
                 }
                 c++;
             }
             rec[i] = cur;
         }
         map<int, int>::iterator mii;
         int ans, tid;
         for (int i = ; i < k; i++) {
             ans = , tid = id[qry[i][]];
             for (mii = rec[tid].begin(); mii != rec[tid].end(); mii++) {
                 ans += (*mii).second << bitcnt((*mii).first & qry[i][]);
             }
             printf("%d\n", ans);
         }
     }
     return ;
 }