BZOJ 4242: 水壶（Kruskal重构树 + Bfs）

题意

一块 \(h ∗ w\) 的区域，存在障碍、空地、\(n\) 个建筑，从一个建筑到另一个建筑的花费为：路径上最长的连续空地的长度。

\(q\) 次询问:从建筑 \(s_i\) 到 \(t_i\) 的最小花费。

\(h, w \le 2 \times 10^3 ,n, q \le 2 \times 10^5\)

题解

对于任意两个建筑把它们之间的只走空地的最短路长度作为权值，然后做最小生成树。

如果搞出了最小生成树，那么就只需在 \(kruskal\) 重构树上求 \(LCA\) 就行了，因为 \(LCA\) 的权值是路上所有边的最大权值。

如果不会可以参考 「NOI2018」归程（Dijkstra + Kruskal重构树 + 倍增） 这题。

然而边数达到 \(O(n^2)\) ，暴力求边需要 \(O(n*h*w)\) 。

把所有建筑一起作为源点，跑 \(bfs\) ，可以得到离每个位置最近的建筑及距离。

然后,如果两个相邻位置的最近建筑不同,那么就将这对建筑连边，边数就降成 \(O(h * w)\) 的。

对于一个点如果存在多个最近的点，我们其实只需要把所有点连向第一个 \(bfs\) 到这个的点就行了，可以证明这是对的。（能自己画图理解）

所以最后复杂度就是 \(O(h * w \log (h * w) + q \log n)\)

总结

这种路径上 最大 / 最小 作为权值的题，常常可以考虑 \(kruskal\) 重构树来做。

平面上连边常常可以找特殊点来减少边数。

代码

/**************************************************************
    Problem: 4242
    User: DOFY
    Language: C++
    Result: Accepted
    Time:32156 ms
    Memory:271236 kb
****************************************************************/

#include <bits/stdc++.h>

#define For(i, l, r) for(register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for(register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define fir first
#define sec second
#define mp make_pair

using namespace std;

typedef pair<int, int> PII;

template<typename T> inline bool chkmin(T &a, T b) {return b < a ? a = b, 1 : 0;}
template<typename T> inline bool chkmax(T &a, T b) {return b > a ? a = b, 1 : 0;}

inline int read() {
    int x(0), sgn(1); char ch(getchar());
    for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
    for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
    return x * sgn;
}

void File() {
#ifdef zjp_shadow
    freopen ("4242.in", "r", stdin);
    freopen ("4242.out", "w", stdout);
#endif
}

const int Maxn = 2010, N = 4e5 + 1e3;

bool G[Maxn][Maxn]; char str[Maxn];

queue<PII> Q; int id[Maxn][Maxn], dis[Maxn][Maxn];

struct Edge {
    int u, v, w;
} lt[Maxn * Maxn * 4];

struct Cmp {
    inline bool operator () (const Edge &lhs, const Edge &rhs) const {
        return lhs.w < rhs.w;
    }
};

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

int h, w, p, q;

const int dir[4][2] = { {0, -1}, {0, 1}, {1, 0}, {-1, 0} };

int dep[N], val[N], anc[N][21], Log[N], Size;

int Get_Dep(int u) {
    if (!u || dep[u]) return dep[u];
    return dep[u] = Get_Dep(anc[u][0]) + 1;
}

int tot = 0;
void Build_Kruskal() {
    For (i, 1, Size = p) fa[i] = i;
    sort(lt + 1, lt + tot + 1, Cmp());
    For (i, 1, tot) {
        int u = find(lt[i].u), v = find(lt[i].v), w = lt[i].w;
        if (u == v) continue ;
        val[++ Size] = w;
        fa[Size] =
            anc[u][0] = fa[u] =
            anc[v][0] = fa[v] = Size;
    }
    For (i, 1, Size) {
        if (i > 1) Log[i] = Log[i >> 1] + 1;
        dep[i] = Get_Dep(i);
    }
    For (j, 1, Log[Size]) For (i, 1, Size)
        anc[i][j] = anc[anc[i][j - 1]][j - 1];
}

inline int Calc(int u, int v) {
    if (find(u) != find(v)) return -1;
    if (dep[u] < dep[v]) swap(u, v);
    int gap = dep[u] - dep[v];
    For (i, 0, Log[gap]) if (gap >> i & 1) u = anc[u][i];
    if (u == v) return val[u];
    Fordown (i, Log[dep[u]], 0)
        if (anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i];
    return val[anc[u][0]];
}

int main () {

    File();

    h = read(), w = read(), p = read(), q = read();

    For (i, 1, h) {
        scanf ("%s", str + 1);
        For (j, 1, w) G[i][j] = str[j] == '.';
    }

    Set(dis, -1);
    For (i, 1, p) {
        int x = read(), y = read();
        Q.push(mp(x, y)); id[x][y] = i; dis[x][y] = 0;
    }

    while (!Q.empty()) {
        PII u = Q.front(); Q.pop();
        For (i, 0, 3) {
            register int x = u.fir + dir[i][0], y = u.sec + dir[i][1];
            if (!G[x][y]) continue ;
            if (id[x][y]) {
                if (id[x][y] != id[u.fir][u.sec])
                    lt[++ tot] = (Edge){id[x][y], id[u.fir][u.sec], dis[x][y] + dis[u.fir][u.sec]};
            } else {
                dis[x][y] = dis[u.fir][u.sec] + 1;
                id[x][y] = id[u.fir][u.sec]; Q.push(mp(x, y));
            }
        }
    }

    Build_Kruskal();

    For (i, 1, q)
        printf ("%d\n", Calc(read(), read()));

    return 0;

}