BZOJ 4736 温暖会指引我们前行 LCT+最优生成树+并查集

题目链接：http://uoj.ac/problem/274

题意概述：

　　没什么好概述的......概述了题意就知道怎么做了......我懒嘛

分析：

　　就是用lct维护最大生成树。

　　然后如果去UOJ上面交发现如果不用并查集判断连通性就要T？！

　　然后我就默默改了并查集。。。（hash表并查集输入输出占据了一半的行数？！）

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<set>
 #include<map>
 #include<vector>
 #include<cctype>
 #define inf 1e9+5
 using namespace std;
 const int maxm=;

 int N,M;
 struct edge{ int u,v; }E[maxm];
 struct union_find{
     static const int maxn=;
     int pa[maxn],stk[maxn],top;
     void initial(int n){ for(int i=;i<=n;i++) pa[i]=i; }
     int find(int x){
         while(x!=pa[x]) stk[++top]=x,x=pa[x];
         while(top) pa[stk[top--]]=x;
         return x;
     }
     bool judge(int x,int y){ return find(x)==find(y); }
     void merge(int x,int y){ pa[find(x)]=find(y); }
 }uf;
 struct Link_Cut_Tree{
     static const int maxn=;
     int ch[maxn][],fa[maxn],sum[maxn],w[maxn],mn[maxn],t[maxn];
     bool rev[maxn];
     Link_Cut_Tree(){ mn[]=inf; }
     void link(int x,int d,int y){ ch[x][d]=y,fa[y]=x; }
     bool isrt(int x){ return ch[fa[x]][]!=x&&ch[fa[x]][]!=x; }
     void pushup(int now){
         sum[now]=sum[ch[now][]]+sum[ch[now][]]+w[now];
         mn[now]=min(t[now],min(mn[ch[now][]],mn[ch[now][]]));
     }
     void pushdown(int now){
         if(!rev[now]) return;
         rev[ch[now][]]^=,swap(ch[ch[now][]][],ch[ch[now][]][]);
         rev[ch[now][]]^=,swap(ch[ch[now][]][],ch[ch[now][]][]);
         rev[now]=;
     }
     void rot(int x){
         int y=fa[x],z=fa[y];
         pushdown(y); pushdown(x);
         int d=x==ch[y][];
         if(!isrt(y)) link(z,ch[z][]==y,x); fa[x]=z;
         link(y,d^,ch[x][d]);
         link(x,d,y);
         pushup(y); pushup(x);
     }
     void splay(int x){
         pushdown(x);
         while(!isrt(x)){
             int y=fa[x],z=fa[y];
             if(!isrt(y)) rot((ch[z][]==y)==(ch[y][]==x)?y:x);
             rot(x);
         }
     }
     void access(int x){
         int y=;
         while(x){
             splay(x); ch[x][]=y; pushup(x);
             y=x,x=fa[x];
         }
     }
     void mroot(int x){
         access(x); splay(x);
         rev[x]^=,swap(ch[x][],ch[x][]);
     }
     void Link(int x,int y,int id,int w1,int w2){
         mroot(x); mroot(y);
         w[N+id]=sum[N+id]=w1,t[N+id]=mn[N+id]=w2;
         fa[x]=fa[y]=N+id;
     }
     void Cut(int id,int x,int y){
         mroot(N+id); access(N+id);
         splay(x); fa[x]=;
         splay(y); fa[y]=;
     }
     int query1(int x,int y){
         mroot(y); access(x); splay(x);
         return mn[x];
     }
     int query2(int x,int y){
         mroot(y); access(x); splay(x);
         return sum[x];
     }
 }lct;
 struct Hash{
     static const int maxn=;
     static const int mo=;
     int np,first[mo],next[maxn],id[maxn],val[maxn];
     void ins(int p,int t){
         int i=t%mo;
         next[++np]=first[i],first[i]=np;
         id[np]=p,val[np]=t;
     }
     int find(int t){
         int i=t%mo;
         for(int p=first[i];p;p=next[p])
             if(val[p]==t) return id[p];
         return -;
     }
 }hash;

 void _scanf(int &x)
 {
     x=;
     char c=getchar();
     while(c<''||c>'') c=getchar();
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
 }
 void _scanf(char *s)
 {
     int cnt=;
     char c=getchar();
     while(!isalpha(c)) c=getchar();
     while(isalpha(c)) s[cnt++]=c,c=getchar();
     s[cnt]='\0';
 }
 int out_cnt,out[];
 void _printf(int x)
 {
     if(x<) putchar('-'),x=-x;
     out[++out_cnt]=x%,x/=;
     while(x) out[++out_cnt]=x%,x/=;
     while(out_cnt) putchar(''+out[out_cnt--]);
     putchar('\n');
 }
 void work()
 {
     _scanf(N);_scanf(M);
     uf.initial(N);
     for(int i=;i<=N;i++) lct.t[i]=lct.mn[i]=inf;
     char op[];
     int id,u,v,t,l,x;
     for(int i=;i<=M;i++){
         _scanf(op);
         if(op[]=='f'){
             _scanf(id);_scanf(u);_scanf(v);_scanf(t);_scanf(l);
             u++,v++,id++;
             E[id]=(edge){u,v};
             hash.ins(id,t);
             if(uf.judge(u,v)){
                 x=lct.query1(u,v);
                 if(x<t){
                     x=hash.find(x);
                     lct.Cut(x,E[x].u,E[x].v);
                     lct.Link(u,v,id,l,t);
                 }
             }
             else{
                 lct.Link(u,v,id,l,t);
                 uf.merge(u,v);
             }
         }
         else if(op[]=='m'){
             _scanf(u);_scanf(v); u++,v++;
             _printf(uf.judge(u,v)?lct.query2(u,v):-);
         }
         else if(op[]=='c'){
             _scanf(id);_scanf(l); id++;
             lct.splay(N+id);
             lct.w[N+id]=l;
         }
     }
 }
 int main()
 {
     work();
     return ;
 }