Luogu 2173 [ZJOI2012]网络 - LCT

Solution

$LCT$ 直接上$QuQ$

注意$cut$ 完 需要 $d[u + c * N]--$ 再  $link$,  不然会输出Error 1的哦

Code

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

 const int N = 1e5 + ;

 int n, m, col, Q;

 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 cmax(int &a, int b) {
     if (a < b)
         a = b;
 }

 namespace LCT {
     int val[N], Max[N], f[N], ch[N][], tun[N], d[N];
 #define lc(x) ch[x][0]
 #define rc(x) ch[x][1]
     int isroot(int x) {
         return rc(f[x]) != x && lc(f[x]) != x;
     }

     int get(int x) {
         return rc(f[x]) == x;
     }

     void up(int x) {
         Max[x] = val[x];
         if (lc(x)) cmax(Max[x], Max[lc(x)]);
         if (rc(x)) cmax(Max[x], Max[rc(x)]);
     }

     void rev(int x) {
         swap(lc(x), rc(x));
         tun[x] ^= ;
     }

     void pushdown(int x) {
         if (tun[x]) {
             if (lc(x)) rev(lc(x));
             if (rc(x)) rev(rc(x));
             tun[x] = ;
         }
     }

     void pd(int x) {
         if (!isroot(x))
             pd(f[x]);
         pushdown(x);
     }

     void rotate(int x) {
         int old = f[x], oldf = f[old], son = ch[x][get(x) ^ ];
         if (!isroot(old)) ch[oldf][get(old)] = x;
         ch[x][get(x) ^ ] = old;
         ch[old][get(x)] = son;
         f[old] = x; f[son] = old; f[x] = oldf;
         up(old); up(x);
     }

     void splay(int x) {
         pd(x);
         for (; !isroot(x); rotate(x))
             if (!isroot(f[x]))
                 rotate(get(f[x]) == get(x) ? f[x] : x);
     }

     void access(int x) {
         for (int y = ; x; y = x, x = f[x])
             splay(x), ch[x][] = y, up(x);
     }

     void mroot(int x) {
         access(x); splay(x); rev(x);
     }

     int findr(int x) {
         access(x); splay(x);
         while (lc(x)) pushdown(x), x = lc(x);
         return x;
     }

     void split(int x, int y) {
         mroot(x); access(y); splay(y);
     }

     int link(int x, int y) {
         if (d[x] >  || d[y] > )
             return ;
         mroot(x);
         if (findr(y) == x)
             return ;
         f[x] = y;
         return ;
     }

     int cut(int x, int y) {
         mroot(x);
         if (findr(y) != x || f[x] != y || ch[x][])
             return ;
         f[x] = ch[y][] = ;
         return ;
     }
 }
 using namespace LCT;

 int main()
 {
     n = rd; m = rd; col = rd; Q = rd;
     for (int i = ; i <= n; ++i) {
         int tmp = rd;
         for (int j = ; j < col; ++j)
             val[i + j * n] = tmp;
     }
     for (int i = ; i <= m; ++i) {
         int u = rd, v = rd, z = rd;
         link(u + z * n, v + z * n);
         d[u + z * n]++;
         d[v + z * n]++;
     }
     for (; Q; Q--) {
         int k = rd;
         if (k == ) {
             int u = rd, v = rd;
             for (int j = ; j < col; ++j)
                 mroot(u + j * n), val[u + j * n] = v, up(u + j * n);
         }
         if (k == ) {
             int u = rd, v = rd, z = rd, flag = , c;
             for (int j = ; j < col && !flag; ++j) {
                 flag = cut(u + j * n, v + j * n);
                 if (flag) c = j;
             }
             if (!flag) {puts("No such edge."); continue;}
             d[u + c * n]--; d[v + c * n]--;
             flag = link(u + z * n, v + z * n);
             if (flag == ) {
                 puts("Error 1.");
                 link(u + c * n, v + c * n);
                 d[u + c * n]++; d[v + c * n]++;
             }
             else if (flag == ) {
                 puts("Error 2.");
                 link(u + c * n, v + c * n);
                 d[u + c * n]++; d[v + c * n]++;
             }
             else {
                 puts("Success.");
                 d[u + z * n]++; d[v + z * n]++;
             }
         }
         if (k == ) {
             int z = rd, u = rd, v = rd;
             u = u + z * n;
             v = v + z * n;
             mroot(u);
             if (findr(v) != u) {puts("-1"); continue;}
             printf("%d\n", max(Max[lc(v)], val[v]));
         }
     }
 }