[ZJOI2012]网络

题目描述

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

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

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

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

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

1. 修改一条边的颜色。

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

输入输出格式

输入格式：

输入文件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表示操作类型。

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

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

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

输出格式：

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

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

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

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

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

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

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

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

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

输入输出样例

输入样例#1： 复制

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

输出样例#1： 复制

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

说明

颜色0为实线的边，颜色1为虚线的边，

由颜色0构成的从节点1到节点4的路径有1 – 2 – 4，故max{v1, v2, v4} = max{ 1, 2, 4 } = 4。

将连接节点1和节点2的边修改为颜色1，修改成功，输出“Success.”

将连接节点4和节点3的边修改为颜色1，由于修改后会使得存在由颜色1构成的环( 1 – 2 – 4 – 3 – 1 )，不满足条件2，故不修改，并输出“Error 2”。

不存在颜色0构成的从节点1到节点4的边，输出“-1”。

将连接节点2和节点3的边修改为颜色1，由于修改后节点2的连出去的颜色为1的边有3条，故不满足条件1，故不修改，并输出“Error 1.”。

将节点2的权值修改为5。

由颜色1构成的从节点1到节点4的路径有 1 – 2 – 4，故max{v1, v2, v4} = max{ 1, 5, 4 } = 5。

【数据规模】

对于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。

题解：

思维难度比较低，细节很多，首先看到C<=10，果断开10棵LCT。

　　1.对于操作1，在每一个LCT中修改这个点的点权就好。

　　2.对于操作2，我的方法是用一个链表来存边，如果a和b之间没有边，就输出“No such edge”。用一个数组in来存出度，如果出度>2并且颜色改变，就输出“Error 2.”。然后判断一下这两个点是否联通，如果联通且不是直接联通，就输出“Error 2.”。其他情况直接link就好。

//Never forget why you start
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#define ll(x) lct[x].child[0]
#define rr(x) lct[x].child[1]
#define son(x,t) lct[x].child[t]
using namespace std;
int n,m,C,k;
int in[10005][10];
struct Tree{
  struct LCT{
    int child[2],fa,size,x,mmax,rev;
    bool is_root;
  }lct[10005];
  void push_up(int x){
    lct[x].size=lct[ll(x)].size+lct[rr(x)].size+1;
    lct[x].mmax=max(lct[x].x,max(lct[ll(x)].mmax,lct[rr(x)].mmax));
  }
  void push_rev(int x){
    if(!x)return;
    swap(ll(x),rr(x));
    lct[x].rev^=1;
  }
  void push_down(int x){
    if(lct[x].rev){
      push_rev(ll(x));
      push_rev(rr(x));
      lct[x].rev^=1;
    }
  }
  void push(int x){
    if(!lct[x].is_root)push(lct[x].fa);
    push_down(x);
  }
  int getson(int x){
    return x==son(lct[x].fa,1);
  }
  void rotate(int x){
    if(lct[x].is_root)return;
    int fa=lct[x].fa,fafa=lct[fa].fa,t=getson(x);
    son(fa,t)=son(x,!t);if(son(x,!t))lct[son(x,!t)].fa=fa;
    lct[fa].fa=x;son(x,!t)=fa;
    lct[x].fa=fafa;
    if(!lct[fa].is_root)son(fafa,son(fafa,1)==fa)=x;
    else lct[x].is_root=1,lct[fa].is_root=0;
    push_up(fa);
    push_up(x);
  }
  void splay(int x){
    push(x);
    for(int fa;!lct[x].is_root;rotate(x))
      if(!lct[fa=lct[x].fa].is_root)
    rotate(getson(fa)==getson(x)?fa:x);
  }
  void access(int x){
    int y=0;
    do{
      splay(x);
      lct[rr(x)].is_root=1;
      lct[rr(x)=y].is_root=0;
      push_up(x);
      x=lct[y=x].fa;
    }while(x);
  }
  void mroot(int x){
    access(x);
    splay(x);
    push_rev(x);
  }
  void link(int u,int v){
    mroot(u);
    lct[u].fa=v;
  }
  void cut(int u,int v){
    mroot(u);
    access(v);splay(v);
    lct[ll(v)].fa=lct[v].fa;
    lct[ll(v)].is_root=1;
    ll(v)=lct[v].fa=0;
    push_up(v);
  }
  void change(int x,int y){
    mroot(x);
    lct[x].x=y;
    push_up(x);
  }//修改点
  bool judge(int x,int y){
    access(x);splay(x);while(ll(x))x=ll(x);
    access(y);splay(y);while(ll(y))y=ll(y);
    return x==y;
  }
  bool pd(int x,int y){
    mroot(x);
    access(y);splay(y);
    return (ll(y)==x)&&lct[ll(y)].size==1;
  }
  int query(int x,int y){
    mroot(x);
    access(y);splay(y);
    return lct[y].mmax;
  }
}T[10];
struct node{
  int next,to,dis;
}edge[200005];
int head[10005],size=-1;
void putin(int from,int to,int dis){
  size++;
  edge[size].next=head[from];
  edge[size].to=to;
  edge[size].dis=dis;
  head[from]=size;
}
int main(){
  int i,j;
  memset(head,-1,sizeof(head));
  scanf("%d%d%d%d",&n,&m,&C,&k);
  for(i=1;i<=n;i++){
    int x;scanf("%d",&x);
    for(j=0;j<C;j++){
      T[j].lct[i].size=T[j].lct[i].is_root=1;
      T[j].lct[i].x=T[j].lct[i].mmax=x;
    }
  }
  for(i=1;i<=m;i++){
    int u,v,c;
    scanf("%d%d%d",&u,&v,&c);
    putin(u,v,c);
    putin(v,u,c);
    in[u][c]++;
    in[v][c]++;
    T[c].link(u,v);
  }
  for(i=1;i<=k;i++){
    int a,b,c,d;
    scanf("%d%d%d",&d,&a,&b);
    if(d==0){
      
      for(j=0;j<C;j++)
    T[j].change(a,b);
      
    }
    else if(d==1){
      
      scanf("%d",&c);
      
      bool flag=0;
      for(j=head[a];j!=-1;j=edge[j].next)if(edge[j].to==b){flag=1;break;}
      if(!flag){printf("No such edge.\n");continue;}
      
      int last=edge[j].dis;
      if((in[a][c]==2&&last!=c)||(in[b][c]==2&&last!=c)){printf("Error 1.\n");continue;}

      if(T[c].judge(a,b)&&(!T[c].pd(a,b))){printf("Error 2.\n");continue;}
      
      in[a][last]--;in[b][last]--;
      in[a][c]++;in[b][c]++;
      edge[j].dis=c;edge[j^1].dis=c;
      T[last].cut(a,b);
      T[c].link(a,b);
      printf("Success.\n");
      
    }
    else if(d==2){
      
      scanf("%d",&c);
      
      if(!T[a].judge(b,c))printf("-1\n");
      else printf("%d\n",T[a].query(b,c));
      
    }
  }
  return 0;
}