[SDOI 2019]世界地图[虚树][MST]

菜啊，被迫文化课还天天颓，不知道过了多久才补上这篇题解，但是 zhq 讲的真好

虚树相关知识

---

简述题意：给定一张 $n\times m$ 的网格图，其中最左端的一排点和最右端的一排点再相连，形成一个圆柱形网格图，边有边权。可以将横纵线理解为经纬线

然后有 q 次询问，每次删除经度在 $[l, r]$ 这个区间的图，求剩下部分的 MST（最小生成树）

数据范围：$n\leq 100, m\leq 10000, q\leq 10000$

---

可以想到，对于一次询问的图，其实就是 以第一排点开始的某个前缀图 + 以第 m 排点开始的某个后缀图 + 第 1 排点与第 m 排点相连的边 形成的一张图的 MST

求出每一个前缀图的 MST，再求出每一个后缀图的 MST，加上 $1\rightarrow m$ 的那一排边，这样会形成很多环，来考虑怎样将这些环搞掉

因为这些图是网格图，所以对于一个环，只需要删除掉这个环上边权最大的边即可

但是这样显然复杂度爆炸，实际上可能被删除的边有 $O(N^2)$ 条？其实是 $O(N)$ 条

来考虑虚树

对于前缀图，我们将第 1 排点全部设为 key 点；对于后缀图，我们将第 m 排点全部设为 key 点，在 MST 上形成一棵虚树

这样的一棵虚树的一条边表示原图 MST 上的一条链

可以从构造上发现，对于这样的一棵虚树，它只有 $O(N)$ 条边和 $O(N)$ 个点

（原因是因为每个非叶子节点都至少有两个儿子，如同 SAM 只有 O(N) 个点的原因 —— zhq）

这样我们虚树上的每一条边表示它所代表的那一条链上边权最大的边的边权

然后对于整张图（前缀虚树+后缀虚树+一排边）求一遍 MST 即可

需要注意的是，我们是在虚树上求 MST，所以这个 MST 并不是答案，原树上还有不少不可能被删除的边没有被统计

那我们可以额外记录一下，不可能被删除的边的边权和

可能被删的边只有虚树上的边以及那一排边

那么最后答案就是 = 前缀图中一定不可能被删的边权和 + 后缀图中一定不可能被删的边权和 + （前缀虚树+后缀虚树+一排边 的 MST）

好像做完了

但是还有个问题没有解决：怎样求出前缀图虚树和后缀图虚树

以前缀为例子：假设我们已经求出了 i-1 的前缀图的虚树，考虑如何求出 i 的前缀图的虚树

其实和上面计算答案的方法一样，把 i-1 的那个前缀图当作计算答案时的后缀图，第 i 排点是计算答案时的前缀图，再加上 $(i-1)\rightarrow i$ 那一排边

按照上面计算答案的算法做，即可完成。后缀同理

另外需要注意的是，这道题我(zhq)所用的建造虚树的方法并不适用于所有虚树构造

复杂度：大概是 $O(nm+qn)$？

代码（适当的加了几个注释）：

// #3112. 「SDOI2019」世界地图
// MST + 虚树

#include <ctime>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#define inf 10010
#define N 110
#define INF 0x7fffffff
#define ll long long

namespace chiaro{

template <class I>
inline void read(I &num){
    num = 0; char c = getchar(), up = c;
    while(c < '0' || c > '9') up = c, c = getchar();
    while(c >= '0' && c <= '9') num = (num << 1) + (num << 3) + (c ^ '0'), c = getchar();
    up == '-' ? num = -num : 0; return;
}
template <class I>
inline void read(I &a, I &b) {read(a); read(b);}
template <class I>
inline void read(I &a, I &b, I &c) {read(a); read(b); read(c);}

struct MSTedge {
    int from;
    int to;
    int val;
    MSTedge() {}
    MSTedge(int from, int to, int val) {
        this->from = from;
        this->to = to;
        this->val = val;
    }
};

struct edge {
    int to;
    int val;
    edge* next;
};

int n, m;
ll ansdis;
int id[N][inf]; // id
int right[N][inf], down[N][inf]; // 向右边权 & 向下边权
bool isKey[inf * N]; // 是否是 key 点
edge* g[inf * N];

int fa[inf * N];

struct MST {
    ll sum; // MST 上不可能被删的边的边权之和
    std::vector <MSTedge> e;

    MST() {}
    MST(int now) { // 搞出 now 那一列点的 MST
        sum = 0;
        for(int i = 1; i < n; i++) 
            e.push_back(MSTedge(id[i][now], id[i + 1][now], down[i][now]));
        return;
    }

    inline int size() {return e.size();}
};

MST pre[inf], suf[inf]; // 前缀 & 后缀

bool edgeflag;
inline void connect(int from, int to, int val){
    static edge pool[inf * N];
    static edge* p = pool;
    if(edgeflag) p = pool, edgeflag = 0; // 清空
    p->to = to;
    p->val = val;
    p->next = g[from];
    g[from] = p; p++;
    return;
}

namespace gen {
    unsigned int SA, SB, SC;int lim;
    int getweight() {
        SA ^= SA << 16;
        SA ^= SA >> 5;
        SA ^= SA << 1;
        unsigned int t = SA;
        SA = SB;
        SB = SC;
        SC ^= t ^ SA;
        return SC % lim + 1;
    }

    void gen() {
        read(n, m);
        read(SA, SB, SC);
        read(lim);
        int i, j, w;
        for(i = 1; i <= n; i++)
            for(j = 1; j <= m; j++) {
                w = getweight();
                right[i][j] = w;
            }
        for(i = 1; i < n; i++)
            for(j = 1; j <= m; j++) {
                w = getweight();
                down[i][j] = w;
            }
        int index = 0;
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) id[i][j] = ++index;
        }
        return;
    }
}

int findf(int f) {return ((f == fa[f]) ? (f) : (fa[f] = findf(fa[f])));}

inline void clear(const std::vector <MSTedge>& V) {
    for(unsigned int i = 0; i < V.size(); i++) {
        fa[V[i].from] = V[i].from;
        fa[V[i].to] = V[i].to;
        g[V[i].from] = NULL;
        g[V[i].to] = NULL;
    }
    edgeflag = 1;
    return;
}

inline bool cmp(MSTedge& a, MSTedge& b) {return a.val < b.val;}

inline ll kruskal(std::vector <MSTedge>& V) {
    srand(time(0));
    ll ans = 0;
    std::sort(V.begin(), V.end(), cmp);
    for(unsigned int i = 0; i < V.size(); i++) {
        int u = V[i].from, v = V[i].to, w = V[i].val;
        int fau = findf(u);
        int fav = findf(v);
        if(fav == fau) continue;
        ans += w, ansdis += w; // ansdis 存 MST 中不会被删的边的边权
        // 我们先将他定为 MST 边权和,再在后面减去新虚树中的边的边权
        (rand() & 1) ? (fa[fav] = fau) : (fa[fau] = fav);
        connect(u, v, w);
        connect(v, u, w);
    }
    return ans;
}

bool buildVT(int now, int f) { // 处理出所有 key 点
    int tot = isKey[now];
    // tot 是 自己是否是key点 与 有key点的子树 的数量和
    for(edge* e = g[now]; e; e = e->next) {
        int to = e->to;
        if(to == f) continue;
        tot += buildVT(to, now);
    }
    if(tot >= 2) isKey[now] = 1;
    return !!tot;
}

// 将上面处理出来的 key 连边形成虚树
// last 是上面的那个 key 点, max 是路径上的权值最大值
void processVal(int now, int f, int last, int max, std::vector <MSTedge>& V) {
    if(isKey[now]) {
        if(last) {
            V.push_back(MSTedge(now, last, max));
            ansdis -= max;
        }
        last = now, max = 0;
    }
    for(edge* e = g[now]; e; e = e->next) {
        int to = e->to;
        if(to == f) continue;
        processVal(to, now, last, std::max(max, e->val), V);
    }
    return;
}

#define nextpos(x) ((x == m) ? (1) : (x + 1))

// type: 1(pre), 2(suf), 3(process answer)
// 将 a 与 b 与 x 那一列向右的一排边合并
inline MST merge(MST& a, MST& b, int x, int type) {
    static std::vector <MSTedge> V;
    // 存储 a虚树 与 b虚树 与 x 向右的那一排边
    MST ans; ansdis = 0; V.clear();
    for(int i = 0; i < a.size(); i++) V.push_back(a.e[i]);
    for(int i = 0; i < b.size(); i++) V.push_back(b.e[i]);
    for(int i = 1; i <= n; i++)
        V.push_back(MSTedge(id[i][x], id[i][nextpos(x)], right[i][x]));
    
    clear(V);
    ll mstval = kruskal(V);

    if(type == 3) { // 前后缀合并那就直接做完了
        ans.sum = a.sum + b.sum + mstval;
        return ans;
    } else if(type == 1) { // 后面两种情况就开始求 虚树
        for(int i = 1; i <= n; i++) {
            isKey[id[i][1]] = 1;
            isKey[id[i][x + 1]] = 1;
        }
    } else {
        for(int i = 1; i <= n; i++) {
            isKey[id[i][m]] = 1;
            isKey[id[i][x]] = 1;
        }
    }

    buildVT(V[0].from, 0); // 处理虚树
    V.clear();
    processVal(V[0].from, 0, 0, 0, V); // 处理出虚树
    for(unsigned int i = 0; i < V.size(); i++)
        isKey[V[i].from] = isKey[V[i].to] = 0;
    ans.e = V;
    ans.sum = a.sum + b.sum + ansdis;
    return ans;
}

inline void getPre() {
    pre[1] = MST(1);
    for(int i = 2; i <= m; i++) {
        pre[i] = MST(i);
        pre[i] = merge(pre[i - 1], pre[i], i - 1, 1);
    }
    return;
}

inline void getSuf() {
    suf[m] = MST(m);
    for(int i = m - 1; i; i--) {
        suf[i] = MST(i);
        suf[i] = merge(suf[i + 1], suf[i], i, 2);
    }
    return;
}

inline void setting(){
#ifndef ONLINE_JUDGE
    freopen("_test.in", "r", stdin);
    freopen("_test.out", "w", stdout);
#endif
    return;
}

inline int main(){
    setting();
    gen::gen();
    getPre(); getSuf();
    int T; read(T);
    while(T--) {
        int l, r; read(l, r);
        printf("%lld\n", merge(suf[r + 1], pre[l - 1], m, 3).sum);
    }
    return 0;
}

}

signed main(){ return chiaro::main();}