CF487E Tourists

Solution

先Tarjan求出点双联通分量 并缩点。 用$multiset$维护 点双内的最小点权。

容易发现， 点双内的最小点权必须包括与它相连的割边的点权。 所以我们必须想办法来维护。

所以考虑用割点的点权更新它的父节点， 这样查询 点双 内的最小点权只需要查询本身的 $multiset$ 和 它的父亲节点就可以了。

最后加个树剖就能过啦！

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
#define rd read()
using namespace std;

const int N = 2e5 + 5;
const int inf = ~0U >> 2;

int Head[N << 1], Tot;
int head[N], tot;
int low[N], dfn[N], cnt, col, c[N], nd_num, cut[N];
int st[N], tp;
int n, m, Q, a[N];
int f[N << 1], top[N << 1], sz[N << 1], son[N << 1], mk, id[N << 1], dep[N << 1];

vector<int> q[N];
multiset<int> S[N << 2];

struct edge {
    int nxt, to;
}e[N << 2], E[N << 2];

int read() {
    int X = 0, p = 1; char c = getchar();
    for (; c > '9' || c < '0'; c = getchar()) 
        if (c == '-') p = -1;
    for (; c >= '0' && c <= '9'; c = getchar())
        X = X * 10 + c - '0';
    return X * p;
}

void add(int u, int v) {
    e[++tot].to = v;
    e[tot].nxt = head[u];
    head[u] = tot;
}

void Add(int u, int v) {
    E[++Tot].to = v;
    E[Tot].nxt = Head[u];
    Head[u] = Tot;
}

void tarjan(int u) {
    low[u] = dfn[u] = ++cnt;
    st[++tp] = u;
    int flag = 0;
    for (int i = head[u]; i; i = e[i].nxt) {
        int nt = e[i].to;
        if (!dfn[nt]) {
            tarjan(nt);
            low[u] = min(low[u], low[nt]);
            if (low[nt] < dfn[u]) 
                continue;
            col++; flag++;
            cut[u] = 1;
            for (; tp;) {
                int z = st[tp--];
                q[col].push_back(z);
                if (z == nt)
                    break;
            }
            q[col].push_back(u);
        }
        else low[u] = min(low[u], dfn[nt]);
    }
    if (flag < 2 && u == 1)
        cut[u] = 0;
}

namespace SegT {

    int MIN[N << 3];

#define mid ((l + r) >> 1)
#define lson nd << 1
#define rson nd << 1 | 1
    
    void up(int nd) {
        MIN[nd] = min(MIN[lson], MIN[rson]);
    }

    void modify(int pos, int d, int l, int r, int nd) {
        if (l == r) {
            MIN[nd] = d;
            return;
        }
        if (pos <= mid)
            SegT::modify(pos, d, l, mid, lson);
        else
            SegT::modify(pos, d, mid + 1, r, rson);
        SegT::up(nd);
    }
    int query(int L, int R, int l, int r, int nd) {
        if (L <= l && r <= R)
            return MIN[nd];
        int tmp = inf;
        if(L <= mid)
            tmp = min(tmp, SegT::query(L, R, l, mid, lson));
        if(mid < R)
            tmp = min(tmp, SegT::query(L, R, mid + 1, r, rson));
        return tmp;
    }

#undef mid
#undef lson
#undef rson
}

namespace SP {

    void dfs1(int u) {
        sz[u] = 1;
        for (int i = Head[u]; i; i = E[i].nxt) {
            int nt = E[i].to;
            if (nt == f[u])
                continue;
            f[nt] = u;
            dep[nt] = dep[u] + 1;
            SP::dfs1(nt);
            sz[u] += sz[nt];
            if(sz[nt] >= sz[son[u]])
                son[u] = nt;
        }
    }

    void dfs2(int u) {
        id[u] = ++mk;
        if (!son[u])
            return;
        top[son[u]] = top[u];
        SP::dfs2(son[u]);
        for (int i = Head[u]; i; i = E[i].nxt) {
            int nt = E[i].to;
            if (nt == f[u] || nt == son[u])
                continue;
            top[nt] = nt;
            SP::dfs2(nt);
        }
    }

    int query(int x, int y) {
        int re = inf, tmp;
        for (; top[x] != top[y];) {
            if (dep[top[x]] < dep[top[y]])
                swap(x, y);
            tmp = SegT::query(id[top[x]], id[x], 1, mk, 1);
            re = min(tmp, re);
            x = f[top[x]];
        }
        if (dep[x] < dep[y])
            swap(x, y);
        tmp = SegT::query(id[y], id[x], 1, mk, 1);
        re = min(tmp, re);
        if (f[y] && y <= col)
            tmp = SegT::query(id[f[y]], id[f[y]], 1, mk, 1);
        re = min(tmp, re);
        return re;
    }
}

int main()
{
    n = rd; m = rd; Q = rd;
    for (int i = 1; i <= n; ++i)
        a[i] = rd;
    for (int i = 1; i <= m; ++i) {
        int u = rd, v = rd;
        add(u, v); add(v, u);
    }
    tarjan(1);
    nd_num = col;
    for (int i = 1; i <= n; ++i)
        if (cut[i]) c[i] = ++nd_num;
    for (int i = 1; i <= col; ++i)
        for (int j = 0, len = q[i].size(); j < len; ++j) {
            int x = q[i][j];
            if (cut[x])
                Add(c[x], i), Add(i, c[x]);
            else c[x] = i;
        }
    dep[1] = 1;
    SP::dfs1(1);
    top[1] = 1;
    SP::dfs2(1);
    for (int i = 1; i <= n; ++i) {
        int x = c[i];
        S[x].insert(a[i]);
        if(x > col)
            S[f[x]].insert(a[i]);
    }
    for (int i = 1; i <= nd_num; ++i) {
        int x = *S[i].begin();
        SegT::modify(id[i], x, 1, mk, 1);
    }
    for (; Q; Q--) {
        char ch = getchar();
        while (ch != 'A' && ch != 'C')
            ch = getchar();
        int u = rd, v = rd;
        if (ch == 'C') {
            swap(v, a[u]);
            S[c[u]].erase(S[c[u]].find(v));
            S[c[u]].insert(a[u]);
            int x = *S[c[u]].begin();
            SegT::modify(id[c[u]], x, 1, mk, 1);
            if (c[u] <= col)
                continue;
            S[f[c[u]]].erase(S[f[c[u]]].find(v));
            S[f[c[u]]].insert(a[u]);
            x = *S[f[c[u]]].begin();
            SegT::modify(id[f[c[u]]], x, 1, mk, 1);
        }
        else {
            if (u == v) printf("%d
", a[u]);
            else printf("%d
", SP::query(c[u], c[v]));
        }
    }
}