BZOJ2816:[ZJOI2012]网络(LCT)

Description

　　有一个无向图G，每个点有个权值，每条边有一个颜色。这个无向图满足以下两个条件：

1. 对于任意节点连出去的边中，相同颜色的边不超过两条。

2. 图中不存在同色的环，同色的环指相同颜色的边构成的环。

　　 在这个图上，你要支持以下三种操作：

1. 修改一个节点的权值。

2. 修改一条边的颜色。

3. 查询由颜色c的边构成的图中，所有可能在节点u到节点v之间的简单路径上的节点的权值的最大值。

Input

　 　输入文件network.in的第一行包含四个正整数N, M, C, K，其中N为节点个数，M为边数，C为边的颜色数，K为操作数。

　 　接下来N行，每行一个正整数vi，为节点i的权值。

　 　之后M行，每行三个正整数u, v, w，为一条连接节点u和节点v的边，颜色为w。满足1 ≤ u, v ≤ N，0 ≤ w < C，保证u ≠ v，且任意两个节点之间最多存在一条边(无论颜色)。

　　 最后K行，每行表示一个操作。每行的第一个整数k表示操作类型。

1. k = 0为修改节点权值操作，之后两个正整数x和y，表示将节点x的权值vx修改为y。

2. k = 1为修改边的颜色操作，之后三个正整数u, v和w，表示将连接节点u和节点v的边的颜色修改为颜色w。满足0 ≤ w < C。

3. k = 2为查询操作，之后三个正整数c, u和v，表示查询所有可能在节点u到节点v之间的由颜色c构成的简单路径上的节点的权值的最大值。如果不存在u和v之间不存在由颜色c构成的路径，那么输出“-1”。

Output

　　 输出文件network.out包含若干行，每行输出一个对应的信息。

1. 对于修改节点权值操作，不需要输出信息。

2. 对于修改边的颜色操作，按以下几类输出：

　　　　a) 若不存在连接节点u和节点v的边，输出“No such edge.”。

　　　　b) 若修改后不满足条件1，不修改边的颜色，并输出“Error 1.”。

　　　　c) 若修改后不满足条件2，不修改边的颜色，并输出“Error 2.”。

　　　　d) 其他情况，成功修改边的颜色，并输出“Success.”。

　　  输出满足条件的第一条信息即可，即若同时满足b和c，则只需要输出“Error 1.”。

1. 对于查询操作，直接输出一个整数。

Sample Input

4 5 2 7
1
2
3
4
1 2 0
1 3 1
2 3 0
2 4 1
3 4 0
2 0 1 4
1 1 2 1
1 4 3 1
2 0 1 4
1 2 3 1
0 2 5
2 1 1 4

Sample Output

4
Success.
Error 2.
-1
Error 1.
5

Solution

一个非常裸的lct……
按颜色维护多颗lct即可
让题意坑了一次……如果改颜色的边之前就是当前颜色的话就Success
在此感谢夫哥向我伸出的援手

Code

 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<cctype>
 #include<algorithm>
 #define N (100000+100)
 using namespace std;
 struct node
 {
     int x,y,c;
 } E[N];
 int n,m,c,k,p=,x,y,z,opt,val;
 int Father[N],Son[N][],Val[N],Max[N],Rev[N],Ind[N];
 bool cmp(node a,node b){return a.x<b.x || (a.x==b.x && a.y<b.y);}

 inline int read()
 {
     int X=,w=; char ch=;
     while(!isdigit(ch)) {w|=ch=='-';ch=getchar();}
     while(isdigit(ch)) X=(X<<)+(X<<)+(ch^),ch=getchar();
     return w?-X:X;
 }

 int Get (int x){return Son[Father[x]][]==x;}
 void Update(int x){Max[x]=max(Val[x],max(Max[Son[x][]],Max[Son[x][]]));}
 int Is_root(int x){return Son[Father[x]][]!=x && Son[Father[x]][]!=x;}

 void Rotate(int x)
 {
     int wh=Get(x);
     int fa=Father[x],fafa=Father[fa];
     if (!Is_root(fa)) Son[fafa][Son[fafa][]==fa]=x;
     Father[fa]=x; Son[fa][wh]=Son[x][wh^];
     if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
     Father[x]=fafa;    Son[x][wh^]=fa;
     Update(fa);    Update(x);
 }

 void Pushdown(int x)
 {
     if (Rev[x] && x)
     {
         if (Son[x][]) Rev[Son[x][]]^=;
         if (Son[x][]) Rev[Son[x][]]^=;
         swap(Son[x][],Son[x][]);
         Rev[x]=;
     }
 }

 void Push(int x){if (!Is_root(x)) Push(Father[x]); Pushdown(x);}
 void Splay(int x)
 {
     Push(x);
     for (int fa; !Is_root(x); Rotate(x))
         if (!Is_root(fa=Father[x]))
             Rotate(Get(fa)==Get(x)?fa:x);
 }

 void Access(int x){for (int y=; x; y=x,x=Father[x]) Splay(x),Son[x][]=y,Update(x);}
 void Make_root(int x){Access(x); Splay(x); Rev[x]^=;}
 int  Find_root(int x){Access(x); Splay(x); while (Son[x][]) x=Son[x][]; return x;}
 void Link(int x,int y){Make_root(x); Father[x]=y;}
 void Cut(int x,int y){Make_root(x); Access(y); Splay(y); Son[y][]=Father[x]=;}
 int  Query(int x,int y){Make_root(x); Access(y); Splay(y); return Max[y];}

 int getid(int x,int y)
 {
     int l=,r=m;
     while (l<=r)
     {
         int mid=(l+r)/;
         if (E[mid].x==x && E[mid].y==y) return mid;
         if (E[mid].x<x || (E[mid].x==x && E[mid].y<y))
             l=mid+;
         else
             r=mid-;
     }
     return ;
 }

 int main()
 {
     n=read(); m=read(); c=read(); k=read();
     for (int i=; i<=n; ++i)
     {
         x=read();
         for (int j=; j<c; ++j)
             Val[i+j*p]=x;
     }
     for (int i=; i<=m; ++i)
     {
         x=read(); y=read(); z=read();
         if (x>y) swap(x,y);
         E[i].x=x, E[i].y=y, E[i].c=z;
         Link(x+z*p,y+z*p);
         Ind[x+z*p]++;
         Ind[y+z*p]++;
     }
     sort(E+,E+m+,cmp);
     for (int i=; i<=k; ++i)
     {
         opt=read();
         switch (opt)
         {
             case :
             {
                 x=read(); val=read();
                 for (int i=; i<c; ++i)
                 {
                     Splay(x+i*p);
                     Val[x+i*p]=val;
                     Update(x+i*p);
                 }
                 break;
             }
             case :
             {
                 x=read(); y=read(); val=read();
                 if (x>y) swap(x,y);
                 int id=getid(x,y);
                 if (id && E[id].c==val)
                 {
                     printf("Success.\n");
                     break;
                 }
                 if (id==)
                 {
                     printf("No such edge.\n");
                     break;
                 }
                 if (Ind[x+val*p]>= || Ind[y+val*p]>=)
                 {
                     printf("Error 1.\n");
                     break;
                 }
                 if (Find_root(x+val*p)==Find_root(y+val*p))
                 {
                     printf("Error 2.\n");
                     break;
                 }
                 Cut(x+E[id].c*p,y+E[id].c*p);
                 Ind[x+E[id].c*p]--;
                 Ind[y+E[id].c*p]--;
                 Link(x+val*p,y+val*p);
                 Ind[x+val*p]++;
                 Ind[y+val*p]++;
                 E[id].c=val;
                 printf("Success.\n");
                 break;
             }
             case :
             {
                 val=read(); x=read(); y=read();
                 if (Find_root(x+val*p)!=Find_root(y+val*p))
                 {
                     printf("-1\n");
                     break;
                 }
                 printf("%d\n",Query(x+val*p,y+val*p));
                 break;
             }
         }
     }
 }