\(\mathcal{Description}\)

  Link.

  在一个 \(n\times m\) 的网格图中，每个格子上是空白 . 或沙子 #，四联通的沙子会连成一个整体。令此时所有沙子块同时开始匀速下落，下落时不同的沙子块不会再连成整体，求最终状态。

  \(nm\le10^6\)。

\(\mathcal{Solution}\)

  虽然切了但考点掌握得并不熟练。

  考虑一列上的两堆沙子，上方一堆所在的块必然会被下方一堆所在的块托住，若从模拟入手，就是“先让后者下落，再让前者下落”。不过在下落过程中，沙块之间互相的限制关系频繁改变，很难直接维护。

  定量分析“托住”的含义。设上块的最终下落高度为 \(f_u\), 下块的最终下落高度为 \(f_v\)，那么同列的沙子为 \(f_u\) 和 \(f_v\) 之间加上的限制形如 \(f_u\le f_v+h\) —— 差分约束嘛。

  如果像我一样对差分约束不敏感，可以尝试这种思考模式：限制复杂 —— 限制关系是一般图 —— 转化为特殊图？（生成树？缩点？圆方树？……）使用一般图上非 NPC 问题的算法？（最短路？2-SAT？差分约束？……）—— 发现限制可以表示为差分约束。

  最后，这个差分约束没有负权，所以 \(\mathcal O(nm\log nm)\) 跑 Dijkstra 即可。

\(\mathcal{Code}\)

/*~Rainybunny~*/

#include <bits/stdc++.h>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

typedef std::pair<int, int> PII;
#define fi first
#define se second

inline void chkmin( int& u, const int v ) { v < u && ( u = v ); }

const int MAXNM = 1e6;
int n, m, cnt, **idx, lasf[MAXNM + 5], lash[MAXNM + 5];
char** grid;
int ecnt, head[MAXNM + 5], dis[MAXNM + 5];
struct Edge { int to, val, nxt; } graph[MAXNM * 2 + 5];

inline void link( const int s, const int t, const int w ) {
    // printf( "%d %d %d\n", s, t, w );
    graph[++ecnt] = { t, w, head[s] }, head[s] = ecnt;
}

struct DSU {
    int fa[MAXNM + 5], siz[MAXNM + 5];
    inline void init( const int s ) { rep ( i, 1, s ) siz[fa[i] = i] = 1; }
    inline int find( const int x ) {
        return x == fa[x] ? x : fa[x] = find( fa[x] );
    }
    inline bool unite( int x, int y ) {
        if ( ( x = find( x ) ) == ( y = find( y ) ) ) return false;
        if ( siz[x] < siz[y] ) x ^= y ^= x ^= y;
        return siz[fa[y] = x] += siz[y], true;
    }
} dsu;

inline void dijkstra() {
    static std::priority_queue<PII, std::vector<PII>, std::greater<PII> > heap;
    rep ( i, 0, cnt ) dis[i] = 0x3f3f3f3f;
    heap.push( { dis[0] = 0, 0 } );
    while ( !heap.empty() ) {
        PII p( heap.top() ); heap.pop();
        if ( dis[p.se] != p.fi ) continue;
        for ( int i = head[p.se], v; i; i = graph[i].nxt ) {
            if ( dis[v = graph[i].to] > p.fi + graph[i].val ) {
                heap.push( { dis[v] = p.fi + graph[i].val, v } );
            }
        }
    }
}

int main() {
    // freopen( "tpt.in", "r", stdin );
    // freopen( "tpt.out", "w", stdout );

    scanf( "%d %d", &n, &m );
    grid = new char*[n + 5], idx = new int*[n + 5];
    rep ( i, 1, n ) {
        grid[i] = new char[m + 5], idx[i] = new int[m + 5];
        scanf( "%s", grid[i] + 1 );
        rep ( j, 1, m ) idx[i][j] = grid[i][j] == '#' ? ++cnt : 0;
    }

    dsu.init( cnt );
    rep ( i, 1, n ) rep ( j, 1, m ) if ( grid[i][j] == '#' ) {
        if ( i > 1 && grid[i - 1][j] == '#' ) {
            dsu.unite( idx[i][j], idx[i - 1][j] );
        }
        if ( j > 1 && grid[i][j - 1] == '#' ) {
            dsu.unite( idx[i][j], idx[i][j - 1] );
        }
    }
    rep ( i, 1, n ) rep ( j, 1, m ) if ( grid[i][j] == '#' ) {
        idx[i][j] = dsu.find( idx[i][j] ), grid[i][j] = '.';
        // fprintf( stderr, "(%d,%d) in %d\n", i, j, idx[i][j] );
    }

    rep ( i, 1, m ) lash[i] = n + 1;
    per ( i, n, 1 ) rep ( j, 1, m ) if ( idx[i][j] ) {
        link( lasf[j], idx[i][j], lash[j] - i - 1 );
        lasf[j] = idx[i][j], lash[j] = i;
    }

    dijkstra();
    // rep ( i, 0, cnt ) fprintf( stderr, "%d\n", dis[i] );

    rep ( i, 1, n ) rep ( j, 1, m ) if ( idx[i][j] ) {
        grid[i + dis[idx[i][j]]][j] = '#';
    }
    rep ( i, 1, n ) puts( grid[i] + 1 );
    return 0;
}