[BZOJ2816][ZJOI2012]网络-Link Cut Tree

网络

Description

有一个无向图G，每个点有个权值，每条边有一个颜色。这个无向图满足以下两个条件：
对于任意节点连出去的边中，相同颜色的边不超过两条。
图中不存在同色的环，同色的环指相同颜色的边构成的环。

在这个图上，你要支持以下三种操作：
修改一个节点的权值。
修改一条边的颜色。
查询由颜色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表示操作类型。

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

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

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

Output

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

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

对于修改边的颜色操作，按以下几类输出：
a) 若不存在连接节点u和节点v的边，输出“No such edge.”。
b) 若修改后不满足条件1，不修改边的颜色，并输出“Error 1.”。
c) 若修改后不满足条件2，不修改边的颜色，并输出“Error 2.”。
d) 其他情况，成功修改边的颜色，并输出“Success.”。
输出满足条件的第一条信息即可，即若同时满足b和c，则只需要输出“Error 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

Hint

对于30%的数据：N ≤ 1000，M ≤ 10000，C ≤ 10，K ≤ 1000。
另有20%的数据：N ≤ 10000，M ≤ 100000，C = 1，K ≤ 100000。
对于100%的数据：N ≤ 10000，M ≤ 100000，C ≤ 10，K ≤ 100000。

---

咱只是来写LCT练练手的……
然后就被虐惨了。。。。。。
调了整整一晚上啊啊啊啊啊

(╯‵□′)╯︵┻━┻

---

思路:
观察数据范围，c<=10。
再观察题目条件2，因为每种颜色不存在环，所以如果单独拿出某种颜色的边时，将会得到一个森林。
那么可以对每种颜色分开成一个个森林考虑，这样就变成了树上问题。

考虑到原图不变，那么可以维护每个点的领接表来查询连通性，同时维护每种颜色每个点与多少条边相连。
这样做可以很方便地查询错误信息。
对于询问，可以发现询问是经典的链上最大值。
那么现在要求维护一个支持单点修改、加边删边、求链上最值的问题。
考虑用c棵LCT维护每种颜色的链上最大值，那么这就是一个LCT的裸题了~

细节很多，比如各种错误信息的顺序等。
貌似细节才是本题的难点。。。。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int N=10009;
const int M=100009;
const int K=N*19;

int n,m,c,k;
int ch[M][2],col[M],fa[M],val[M],mx[M];
int beg[M],to[M<<1],nxt[M<<1],ec[M<<1],tot=1;
bool rev[M];
int q[M];

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

inline void chkmax(int &a,int b){if(a<b)a=b;}

inline void add(int u,int v,int c)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    ec[tot]=c;
    beg[u]=tot;
}

inline bool isroot(int x)
{
    return (ch[fa[x]][0]!=x) && (ch[fa[x]][1]!=x);
}

inline void update(int x)
{
    mx[x]=val[x];
    if(ch[x][0])chkmax(mx[x],mx[ch[x][0]]);
    if(ch[x][1])chkmax(mx[x],mx[ch[x][1]]);
}

inline void push(int x)
{
    if(rev[x])
    {
        swap(ch[x][0],ch[x][1]);
        if(ch[x][0])rev[ch[x][0]]^=1;
        if(ch[x][1])rev[ch[x][1]]^=1;
        rev[x]=0;
    }
}

inline void rotate(int x)
{
    int y=fa[x],z=fa[y];
    int l=(ch[y][1]==x);
    if(!isroot(y))ch[z][ch[z][1]==y]=x;
    fa[x]=z;fa[y]=x;fa[ch[x][l^1]]=y;
    ch[y][l]=ch[x][l^1];ch[x][l^1]=y;
    update(y);update(x);
}

inline void splay(int x)
{
    int r;q[r=1]=x;
    for(int i=x;!isroot(i);i=fa[i])
        q[++r]=fa[i];
    while(r)push(q[r--]);

    while(!isroot(x))
    {
        int y=fa[x],z=fa[y];
        if(!isroot(y))
        {
            if((ch[z][0]==y)^(ch[y][0]==x))rotate(y);
            else rotate(x);
        }
        rotate(x);
    }
    update(x);
}

inline void access(int x)
{
    for(int t=0;x;t=x,x=fa[x])
    {
        splay(x);
        ch[x][1]=t;
        if(t)fa[t]=x;
        update(x);
    }
}

inline void makeroot(int x)
{
    access(x);splay(x);
    rev[x]^=1;
}

inline void link(int x,int y)
{
    makeroot(x);fa[x]=y;
    col[x]++;col[y]++;
}

inline void cut(int x,int y)
{
    makeroot(x);access(y);splay(y);
    fa[x]=0;ch[y][0]=0;
    update(y);col[x]--;col[y]--;
}

inline bool connect(int x,int y)
{
    while(fa[x])x=fa[x];
    while(fa[y])y=fa[y];
    return x==y;
}

inline int query(int x,int y)
{
    makeroot(x);access(y);splay(y);
    return mx[y];
}

inline int pos(int x,int color)
{
    return color*n+x;
}

int main()
{
    n=read();m=read();c=read();k=read();
    for(int i=1;i<=n;i++)
    {
        val[i]=mx[i]=read();
        for(int j=1;j<c;j++)
            val[pos(i,j)]=mx[pos(i,j)]=val[i];
    }   

    for(int i=1,u,v,w;i<=m;i++)
    {
        u=read();v=read();w=read();
        link(pos(u,w),pos(v,w));
        add(u,v,w);add(v,u,w);
    }

    while(k--)
    {
        int ty=read(),x,y,w,v;
        if(ty==0)
        {
            x=read();y=read();
            for(int i=0;i<c;i++)
            {
                splay(pos(x,i));
                val[pos(x,i)]=y;
                update(pos(x,i));
            }
        }
        else if(ty==1)
        {
            x=read();y=read();w=read();
            for(int i=beg[x];i;i=nxt[i])
                if(to[i]==y)
                {
                    v=i;
                    goto nxts;
                }
            puts("No such edge.");
            continue;
            nxts:;
            if(ec[v]==w)
            {
                puts("Success.");
                goto nxt;
            }
            if(col[pos(x,w)]==2 || col[pos(y,w)]==2)
            {
                puts("Error 1.");
                goto nxt;
            }
            if(connect(pos(x,w),pos(y,w)))
            {
                puts("Error 2.");
                goto nxt;
            }
            cut(pos(x,ec[v]),pos(y,ec[v]));
            link(pos(x,w),pos(y,w));
            ec[v]=ec[v^1]=w;
            puts("Success.");
        }
        else
        {
            w=read();x=read();y=read();
            if(!connect(pos(x,w),pos(y,w)))puts("-1");
            else printf("%d\n",query(pos(x,w),pos(y,w)));
        }
        nxt:;
    }

    return 0;
}