CF487E Tourists - Tarjan缩点 + 树剖 + multiset

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 + ;
 const int inf = ~0U >> ;

 int Head[N << ], 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 << ], top[N << ], sz[N << ], son[N << ], mk, id[N << ], dep[N << ];

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

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

 int read() {
     int X = , p = ; char c = getchar();
     for (; c > '' || c < ''; c = getchar())
         if (c == '-') p = -;
     for (; c >= '' && c <= ''; c = getchar())
         X = X *  + c - '';
     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 = ;
     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] = ;
             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 <  && u == )
         cut[u] = ;
 }

 namespace SegT {

     int MIN[N << ];

 #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 + , 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 + , r, rson));
         return tmp;
     }

 #undef mid
 #undef lson
 #undef rson
 }

 namespace SP {

     void dfs1(int u) {
         sz[u] = ;
         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] + ;
             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], , mk, );
             re = min(tmp, re);
             x = f[top[x]];
         }
         if (dep[x] < dep[y])
             swap(x, y);
         tmp = SegT::query(id[y], id[x], , mk, );
         re = min(tmp, re);
         if (f[y] && y <= col)
             tmp = SegT::query(id[f[y]], id[f[y]], , mk, );
         re = min(tmp, re);
         return re;
     }
 }

 int main()
 {
     n = rd; m = rd; Q = rd;
     for (int i = ; i <= n; ++i)
         a[i] = rd;
     for (int i = ; i <= m; ++i) {
         int u = rd, v = rd;
         add(u, v); add(v, u);
     }
     tarjan();
     nd_num = col;
     for (int i = ; i <= n; ++i)
         if (cut[i]) c[i] = ++nd_num;
     for (int i = ; i <= col; ++i)
         for (int j = , 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[] = ;
     SP::dfs1();
     top[] = ;
     SP::dfs2();
     for (int i = ; i <= n; ++i) {
         int x = c[i];
         S[x].insert(a[i]);
         if(x > col)
             S[f[x]].insert(a[i]);
     }
     for (int i = ; i <= nd_num; ++i) {
         int x = *S[i].begin();
         SegT::modify(id[i], x, , mk, );
     }
     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, , mk, );
             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, , mk, );
         }
         else {
             if (u == v) printf("%d\n", a[u]);
             else printf("%d\n", SP::query(c[u], c[v]));
         }
     }
 }