COJ 0650 绝世难题（一） 可爱的仙人掌

传送门：http://oj.cnuschool.org.cn/oj/home/problem.htm?problemID=620

绝世难题（一） 可爱的仙人掌

难度级别：E； 运行时间限制：1000ms； 运行空间限制：262144KB； 代码长度限制：2000000B

试题描述

---“神犇是怎么样的。。。”

---“神犇就是这种**题拿过来半小时随便A。。。(๑•̀ㅂ•́)و✧”

 

绝世难题之可爱的仙人掌

-------------------------我是题目和吐槽的分割线-------------------------

 

chx童鞋最近迷上了图论中的环，结果有一天他做梦都梦见了环。。。（¯﹃¯）

---“你最近一直研究我啊那你知道我有什么小名嘛？(,,• ₃ •,,)”

---“噗。。。我怎么知道你告诉我呗。。。Σ( ° △ °|||)︴”

---“其实嘛，我的小名叫做仙人掌了啊~”

噗。。。chx脑中不禁脑补了一下。。。(ㆀ˘･з･˘)

噗噗噗。。。chx心想好吧你说是就算是吧(⊙ ▽ ⊙)

---“其实呢，在一个无向连通图中呢，如果每一条边都只属于一个简单环，我们就把这个图叫做仙人掌。。。如果图中每一个连通块都是一个萌萌哒仙人掌且没有自环，那么我们就把这个图称作是沙漠。。。”

呵呵。。。好吧真的 好好好形象啊！！！(๑•̀ㅂ•́)و✧

如果一个无向图的每个连通块都是个仙人掌，且不存在自环，我们就称之为沙漠。

现在呢，为了证明你是玩转仙人掌的神犇，chx给你 n 个结点，从 1 到 n 标号。

初始时没有任何边，且每个结点 i 有个权值 wi (wi>0) 。每次进行如下操作之一：

 

link v uw：在结点 v,u 间连一条权值为 w 的边。

1≤v,u≤n 且 w 为正整数。

如果连边完成后图仍为沙漠，则输出 "ok"（不含引号）。

否则操作非法，撤销此次操作并输出 "failed"（不含引号）。

 

cut v uw：在结点 v,u 间删掉一条权值为 w 的边。

1≤v,u≤n 且 w 为正整数。

如果存在这样的边则输出 "ok"（不含引号）（如果有多条权值为 w 的边删去任意一条）。

否则操作非法，不进行操作并输出 "failed"（不含引号）。

 

query1 vu：查询结点 v 到结点 u 的最短路信息。

1≤v,u≤n。

输出两个用空格隔开的整数 min,σ，分别代表最短路上点权的最小值、和。

如果没有路可到达则 min=−1,σ=−1。

如果最短路不唯一则 min=−2,σ=−2。

 

query2 vu：查询以结点 v 为根，子仙人掌 u 的信息。

1≤v,u≤n。

以结点 v 为根，子仙人掌 u 的定义是，删掉v 到 u 之间的所有简单路径上的边之后，u 所在的连通块。

输出两个用空格隔开的整数 min,σ，分别代表子仙人掌 u 中点权的最小值、和。

如果 v,u 不连通则 min=−1,σ=−1。

 

add1 v ud：把结点 v 到结点 u 的最短路上的每一个结点的权值都加上 d。

1≤v,u≤n 且 d 为正整数。

如果有路可到达且最短路唯一，则输出 "ok"（不含引号）

否则操作非法，不进行操作并输出 "failed"（不含引号）。

 

add2 v ud：把以结点 v 为根，子仙人掌 u 的每一个结点的权值都加上 d。

1≤v,u≤n 且 d 为正整数。

如果 v,u 在同一个连通块里，则输出 "ok"（不含引号）

否则操作非法，不进行操作并输出 "failed"（不含引号）。

 

现在你来负责搞定这个问题吧。。。

输入

第一行两个用空格隔开的正整数 n,m 表示一共有 n 个结点，m 个操作。

接下来一行 n 个正整数，第 i 个正整数为 wi。

接下来 m 行，每行代表一个操作。

输出

对于每个操作，输出相应的结果。

输入示例

11 23
10 5 11 7 8 14 30 3 16 20 19
link 1 2 5
link 2 3 3
link 3 4 7
link 4 5 8
link 2 6 10
link 6 7 15
link 4 7 3
link 6 8 9
link 6 8 6
link 7 9 12
link 9 11 10
link 7 10 4
link 9 10 8
query1 6 11
query1 2 10
query2 8 7
add1 8 5 100
query1 1 7
query2 8 7
add2 11 7 1000
query1 8 3
add2 3 2 2333
query1 1 5

输出示例

ok
ok
ok
ok
ok
ok
ok
ok
ok
ok
ok
ok
ok
-2 -2
5 73
16 85
ok
5 263
16 185
ok
1005 4233
ok
1011 9907

其他说明

1≤n≤50000,1≤m≤250000。
保证 link 和 cut 操作中的 w 满足 1≤w≤10000，所以关于边权的计算不会超出 32 位有符号整数范围。
保证初始的 wi 不超过 109，保证所有 add1 和 add2 操作中的 d 之和不超过 109。


---真心吐槽这道题应该是本OJ代码长度最长的题呦→_→chx童鞋的极限缩行可是写了612行呢。。。

 

题解：动态仙人掌哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

最棒的仙人掌讲解看这里一共有四节：http://vfleaking.blog.163.com/blog/static/17480763420142176910962/

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
#define PAU putchar(' ')
#define ENT putchar('\n')
#define MAXN 50005
#define MAXM 250005
#define is_NULL_tag(x) ((x)==0)
#define is_NULL_info(x) (x.size==0)
using namespace std;
inline int read(){
    int x=0,sig=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')sig=-1;ch=getchar();}
    while(isdigit(ch))x=10*x+ch-'0',ch=getchar();
    return x*=sig;
}
inline void write(int x){
    if(x==0){putchar('0');return;}if(x<0)putchar('-'),x=-x;
    int len=0,buf[15];while(x)buf[len++]=x%10,x/=10;
    for(int i=len-1;i>=0;i--)putchar(buf[i]+'0');return;
}
char ch;
inline void Pass_Pau(int x){while(x--) getchar();return;}
int n,Q;
struct Info{
    int mi,size;
    long long sum;
};
typedef int Tag;
const Tag NULL_TAG=0;
const Info NULL_INFO=(Info){2147483647,0,0};
inline Info operator + (const Info &a,const Info &b){return (Info){std::min(a.mi,b.mi),a.size+b.size,a.sum+b.sum};}
inline Info operator * (const Info &a,const Tag &b){return a.size ? (Info){a.mi+b,a.size,a.sum+1LL*a.size*b}: a;}
struct splay_node{
    splay_node *s[2],*fa;
    Info x,sum;
    Tag tag,tag_sum;
    inline void add_tag(Tag t){
        x=x*t;sum=sum*t;
        tag=tag+t;tag_sum=tag_sum+t;
        return;
    }
    inline void down(){
        if(is_NULL_tag(tag)) return;
        if(s[0]) s[0]->add_tag(tag);
        if(s[1]) s[1]->add_tag(tag);
        tag=NULL_TAG;
        return;
    }
    inline void update(){
        sum=x;
        if(s[0]) sum=sum+s[0]->sum;
        if(s[1]) sum=sum+s[1]->sum;
        return;
    }
};
splay_node _splay[MAXN+MAXM];
inline int get_parent(splay_node *x,splay_node *&fa){return (fa=x->fa) ? fa->s[1]==x : -1;}
inline void rotate(splay_node *x){
    splay_node *fa,*gfa;
    int t1,t2;
    t1=get_parent(x,fa);
    t2=get_parent(fa,gfa);
    if((fa->s[t1]=x->s[t1^1])) fa->s[t1]->fa=fa;
    fa->fa=x;x->fa=gfa;x->s[t1^1]=fa;
    if(t2!=-1) gfa->s[t2]=x;
    fa->update();
    return;
}
inline void pushdown(splay_node *x){
    static splay_node *stack[MAXN+MAXM];
    int cnt=0;
    while(x){
        stack[cnt++]=x;
        x=x->fa;
    }
    while(cnt--) stack[cnt]->down();
    return;
}
inline splay_node * splay(splay_node *x){
    pushdown(x);
    while(1){
        splay_node *fa,*gfa;
        int t1,t2;
        t1=get_parent(x,fa);
        if(t1==-1) break;
        t2=get_parent(fa,gfa);
        if(t2==-1){
            rotate(x);break;
        }else if(t1==t2){
            rotate(fa);rotate(x);
        }else{
            rotate(x);rotate(x);
        };
    }
    x->update();
    return x;
}
inline splay_node * join(splay_node *a,splay_node *b){
    if(!a) return b;
    if(!b) return a;
    while(a->s[1]) a->down(),a=a->s[1];
    splay(a)->s[1]=b;b->fa=a;
    a->update();
    return a;
}
struct lcc_node;
struct cycle{
    int A,B;
    lcc_node *ex;
};
struct lcc_node{
    lcc_node *s[2],*fa;
    lcc_node *first,*last;
    bool rev;
    bool isedge;
    bool mpath;
    bool hasmpath;
    bool mpathtag;
    bool hasmpathtag;
    bool hascyctag;
    bool hascyc;
    cycle *cyc;
    cycle *cyctag;
    int totlen;
    int len;
    int size;
    Info x,sum,sub,ex,all;
    Tag chain_tag,sub_tag,ex_tag_sum;
    inline void add_rev_tag(){
        std::swap(s[0],s[1]);
        std::swap(first,last);
        rev^=1;
        return;
    }
    inline void add_cyc_tag(cycle *c){
        if(isedge) cyc=c;
        cyctag=c;
        hascyctag=1;
        hascyc=c;
        return;
    }
    inline void add_mpath_tag(bool t){
        mpathtag=t;
        hasmpathtag=1;
        mpath=t&isedge;
        hasmpath=t&(isedge|(size>1));
        return;
    }
    inline void add_chain_tag(Tag t)
    {
        if(is_NULL_tag(t)) return;
        x=x*t;sum=sum*t;
        chain_tag=chain_tag+t;
        all=sum+sub;
        return;
    };
    inline void add_sub_tag(Tag t);
    inline void down(){
        if(rev){
            if(s[0]) s[0]->add_rev_tag();
            if(s[1]) s[1]->add_rev_tag();
            rev=0;
        }
        if(hascyctag){
            if(s[0]) s[0]->add_cyc_tag(cyctag);
            if(s[1]) s[1]->add_cyc_tag(cyctag);
            hascyctag=0;
        }
        if(hasmpathtag){
            if(s[0]) s[0]->add_mpath_tag(mpathtag);
            if(s[1]) s[1]->add_mpath_tag(mpathtag);
            hasmpathtag=0;
        }
        if(!is_NULL_tag(chain_tag)){
            if(s[0]) s[0]->add_chain_tag(chain_tag);
            if(s[1]) s[1]->add_chain_tag(chain_tag);
            chain_tag=NULL_TAG;
        }
        if(!is_NULL_tag(sub_tag)){
            if(s[0]) s[0]->add_sub_tag(sub_tag);
            if(s[1]) s[1]->add_sub_tag(sub_tag);
            sub_tag=NULL_TAG;
        }
        return;
    }
    inline void update();
};
lcc_node lcc[MAXN+MAXM];
lcc_node *_node_tot;
splay_node *splay_root[MAXN+MAXM];
inline void lcc_node::add_sub_tag(Tag t){
    if(is_NULL_tag(t)) return;
    sub=sub*t;ex=ex*t;
    sub_tag=sub_tag+t;
    ex_tag_sum=ex_tag_sum+t;
    all=sum+sub;
    // add tag to splay_root
    int id=this-lcc;
    if(splay_root[id]){
        splay_root[id]->add_tag(t);
    }
}
inline void lcc_node::update(){
    totlen=len;
    hascyc=cyc;
    size=1;
    hasmpath=mpath;
    if(s[0]) totlen+=s[0]->totlen,hascyc|=s[0]->hascyc,size+=s[0]->size,hasmpath|=s[0]->hasmpath;
    if(s[1]) totlen+=s[1]->totlen,hascyc|=s[1]->hascyc,size+=s[1]->size,hasmpath|=s[1]->hasmpath;
    first=s[0]?s[0]->first:this;
    last=s[1]?s[1]->last:this;
    bool s0=s[0],s1=s[1];
    if(isedge){
        if(is_NULL_info(ex)){
            if(s0 && s1){
                sum=s[0]->sum+s[1]->sum;
                sub=s[0]->sub+s[1]->sub;
            }else if(s0){
                sum=s[0]->sum;
                sub=s[0]->sub;
            }else if(s[1]){
                sum=s[1]->sum;
                sub=s[1]->sub;
            }else{
                sub=sum=NULL_INFO;
            }
        }else{
            if(s0 && s1){
                sum=s[0]->sum+s[1]->sum;
                sub=s[0]->sub+s[1]->sub+ex;
            }else if(s0){
                sum=s[0]->sum;
                sub=s[0]->sub+ex;
            }else if(s[1]){
                sum=s[1]->sum;
                sub=s[1]->sub+ex;
            }else{
                sum=NULL_INFO;
                sub=ex;
            }
        }
    }else{
        splay_node *root=splay_root[this-lcc];
        if(root){
            if(s0 && s1){
                sum=s[0]->sum+s[1]->sum+x;
                sub=s[0]->sub+s[1]->sub+root->sum;
            }else if(s0){
                sum=s[0]->sum+x;
                sub=s[0]->sub+root->sum;
            }else if(s[1]){
                sum=s[1]->sum+x;
                sub=s[1]->sub+root->sum;
            }else{
                sub=root->sum;
                sum=x;
            }
        }else{
            if(s0 && s1){
                sum=s[0]->sum+s[1]->sum+x;
                sub=s[0]->sub+s[1]->sub;
            }else if(s0){
                sum=s[0]->sum+x;
                sub=s[0]->sub;
            }else if(s[1]){
                sum=s[1]->sum+x;
                sub=s[1]->sub;
            }else{
                sum=x;
                sub=NULL_INFO;
            }
        }
    }
    all=sum+sub;
    return;
};
inline lcc_node * new_edge_node(int u,int v,int len){
    lcc_node *ret=++_node_tot;
    ret->s[0]=ret->s[1]=ret->fa=NULL;
    ret->first=ret->last=ret;
    ret->rev=0;
    ret->isedge=1;
    ret->hascyctag=ret->hascyc=0;
    ret->cyc=ret->cyctag=NULL;
    ret->totlen=ret->len=len;
    ret->size=1;
    ret->x=ret->sum=ret->sub=ret->ex=ret->all=NULL_INFO;
    ret->chain_tag=ret->sub_tag=ret->ex_tag_sum=NULL_TAG;
    return ret;
}
inline int get_parent(lcc_node *x,lcc_node *&fa){return (fa=x->fa) ? fa->s[0]==x?0:fa->s[1]==x?1:-1 : -1;}
inline void rotate(lcc_node *x){
    int t1,t2;
    lcc_node *fa,*gfa;
    t1=get_parent(x,fa);
    t2=get_parent(fa,gfa);
    if((fa->s[t1]=x->s[t1^1])) fa->s[t1]->fa=fa;
    fa->fa=x;x->fa=gfa;x->s[t1^1]=fa;
    if(t2!=-1) gfa->s[t2]=x;
    fa->update();
    return;
}
inline void pushdown(lcc_node *x){
    static lcc_node *stack[MAXN+MAXM];
    int cnt=0;
    while(1){
        stack[cnt++]=x;
        lcc_node *fa=x->fa;
        if(!fa || (fa->s[0]!=x && fa->s[1]!=x)) break;
        x=fa;
    }
    while(cnt--) stack[cnt]->down();
    return;
}
inline lcc_node * splay(lcc_node *x){
    pushdown(x);
    while(1){
        int t1,t2;
        lcc_node *fa,*gfa;
        t1=get_parent(x,fa);
        if(t1==-1) break;
        t2=get_parent(fa,gfa);
        if(t2==-1){
            rotate(x);break;
        }else if(t1==t2){
            rotate(fa);rotate(x);
        }else{
            rotate(x);rotate(x);
        }
    }
    x->update();
    return x;
}
inline int getrank(lcc_node *x){
    splay(x);
    return 1+(x->s[0]?x->s[0]->size:0);
}
bool _attached[MAXN+MAXM];
inline void detach_rch(lcc_node *x){
    if(!x->s[1]) return;
    int X=x-lcc;
    int id=x->s[1]->first-lcc;
    _attached[id]=1;
    splay_node *p=_splay+id;
    p->s[0]=splay_root[X];
    if(splay_root[X]) splay_root[X]->fa=p;
    p->s[1]=p->fa=NULL;
    p->x=x->s[1]->all;
    p->tag=p->tag_sum=NULL_TAG;
    p->update();
    splay_root[X]=p;
    x->s[1]=NULL;
    return;
}
inline void attach_rch(lcc_node *x,lcc_node *y,int id){
    int X=x-lcc;
    _attached[id]=0;
    splay_node *p=_splay+id;
    splay(p);
    if(p->s[0]) p->s[0]->fa=NULL;
    if(p->s[1]) p->s[1]->fa=NULL;
    splay_root[X]=join(p->s[0],p->s[1]);
    y->add_chain_tag(p->tag_sum);
    y->add_sub_tag(p->tag_sum);
    x->s[1]=y;
    return;
}
inline void attach_rch(lcc_node *x,lcc_node *y,int id,int id2){
    if(_attached[id]) attach_rch(x,y,id);
    else attach_rch(x,y,id2);
    return;
}
inline void attach_rch(lcc_node *x,lcc_node *y){
    if(!y) return;
    attach_rch(x,y,y->first-lcc);
    return;
}
inline lcc_node * access(lcc_node *x){
    lcc_node *ret=NULL;
    int last_ex_last_id;
    while(x){
        lcc_node *t=splay(x)->s[0];
        if(!t){
            detach_rch(x);
            if(ret) attach_rch(x,ret,ret->first-lcc,last_ex_last_id);
            ret=x;x->update();
            x=x->fa;
            continue;
        }
        while(t->s[1]) t->down(),t=t->s[1];
        if(!splay(t)->cyc){
            splay(x);
            detach_rch(x);
            if(ret) attach_rch(x,ret,ret->first-lcc,last_ex_last_id);
            ret=x;x->update();
            x=x->fa;
            continue;
        }
        cycle *c=t->cyc;
        lcc_node *A=lcc+c->A,*B=lcc+c->B,*ex=splay(c->ex);
        bool need_tag_down=false;
        lcc_node *B_ex;
        if(splay(B)->fa==A){
            detach_rch(B);
            B->s[1]=ex;ex->fa=B;B->update();
            need_tag_down=true;
            B_ex=B->s[0]->first;
        }else if(splay(A)->fa==B){
            std::swap(c->A,c->B);std::swap(A,B);ex->add_rev_tag();
            detach_rch(B);
            B->s[1]=ex;ex->fa=B;B->update();
            need_tag_down=true;
            B_ex=B->s[0]->last;
        }else{
            bool f=0;
            if(getrank(A)>getrank(B)){
                std::swap(c->A,c->B);std::swap(A,B);ex->add_rev_tag();
                f=1;
            }
            splay(A)->s[1]->fa=NULL;A->s[1]=NULL;A->update();
            splay(B);detach_rch(B);
            B->s[1]=ex;ex->fa=B;B->update();
            B_ex=f ? B->s[0]->last : B->s[0]->first;
        }
        // add tag to ex
        Tag tag_ex=splay(B_ex)->ex_tag_sum;
        B_ex->ex=NULL_INFO;
        B_ex->update();
        ex=splay(B)->s[1];
        ex->add_chain_tag(tag_ex);
        ex->add_sub_tag(tag_ex);
        B->update();
        splay(x);c->B=x-lcc;
        if(x->s[1]->totlen<x->s[0]->totlen) x->add_rev_tag();
        x->add_mpath_tag(x->s[1]->totlen==x->s[0]->totlen);
        x->down();
        c->ex=x->s[1];x->s[1]->fa=NULL;
        x->s[1]=NULL;
        x->update();
        lcc_node *tmp=splay(x->first);
        tmp->ex=c->ex->all;
        tmp->ex_tag_sum=NULL_TAG;
        tmp->update();
        splay(x);
        if(ret) attach_rch(x,ret,ret->first-lcc,last_ex_last_id);
        x->update();
        last_ex_last_id=c->ex->last-lcc;
        if(splay(A)->s[1]) ret=x,x=x->fa;
        else{
            if(need_tag_down) attach_rch(A,x,c->ex->last-lcc,x->first-lcc);
            A->s[1]=x;x->fa=A;A->update();
            ret=A;x=A->fa;
        }
    }
    return ret;
}
inline void setroot(int x){access(lcc+x)->add_rev_tag();};
inline bool link(int u,int v,int len){
    if(u==v) return false;
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u){
        lcc_node *p=new_edge_node(u,v,len);
        p->fa=splay(lcc+u);
        lcc[u].s[0]=p;
        lcc[u].fa=lcc+v;
        lcc[u].update();
        splay(lcc+v)->s[1]=lcc+u;
        lcc[v].update();
        return true;
    }
    if(t->hascyc) return false;
    lcc_node *ex=new_edge_node(u,v,len);
    cycle *c=new cycle((cycle){u,v,ex});
    ex->add_cyc_tag(c);
    t->add_cyc_tag(c);
    access(lcc+v);
    return true;
}
inline bool cut(int u,int v,int len){
    if(u==v) return false;
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u) return false;
    if(!t->hascyc){
        if(t->size!=3) return false;
        if(t->totlen!=len) return false;
        t=t->s[1];
        if(t->s[0]) t->down(),t=t->s[0];
        splay(t);
        t->s[0]->fa=NULL;t->s[1]->fa=NULL;
        return true;
    }
    t=splay(lcc+v)->s[0];
    while(t->s[1]) t->down(),t=t->s[1];
    cycle *c=splay(t)->cyc;
    if(!c) return false;
    t=splay(lcc+u)->s[1];
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)->cyc!=c) return false;
    lcc_node *ex=c->ex;
    if(ex->size==1 && ex->len==len){
        t->add_cyc_tag(NULL);
        t->add_mpath_tag(0);
        delete c;
        return true;
    }
    if(t->size!=3 || t->len!=len) return false;
    // lcc[u].mpath == 0 !
    ex->add_cyc_tag(NULL);
    ex->add_mpath_tag(0);
    ex->add_rev_tag();
    ex->add_sub_tag(t->ex_tag_sum);
    ex->add_chain_tag(t->ex_tag_sum);
    lcc[u].fa=lcc[v].fa=NULL;
    while(ex->s[0]) ex->down(),ex=ex->s[0];
    splay(ex)->s[0]=lcc+u;lcc[u].fa=ex;ex->update();
    while(ex->s[1]) ex->down(),ex=ex->s[1];
    splay(ex)->s[1]=lcc+v;lcc[v].fa=ex;ex->update();
    delete c;
    return true;
}
inline Info query_path(int u,int v){
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u) return (Info){-1,-1,-1};
    if(t->hasmpath) return (Info){-2,-2,-2};
    return t->sum;
}
inline Info query_subcactus(int u,int v){
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u) return (Info){-1,-1,-1};
    Info ret=splay(lcc+v)->x;
    if(splay_root[v]) ret=ret+splay_root[v]->sum;
    return ret;
}
inline bool modify_path(int u,int v,Tag tag){
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u) return false;
    if(t->hasmpath) return false;
    t->add_chain_tag(tag);
    return true;
}
inline bool modify_subcactus(int u,int v,Tag tag){
    setroot(u);
    lcc_node *t=access(lcc+v);
    while(t->s[0]) t->down(),t=t->s[0];
    if(splay(t)!=lcc+u) return false;
    splay(lcc+v);
    lcc[v].x=lcc[v].x*tag;
    if(splay_root[v]) splay_root[v]->add_tag(tag);
    lcc[v].update();
    return true;
}
void init(){
    n=read();Q=read();
    int i;
    static int w[MAXN];
    for(i=1;i<=n;i++){
        w[i]=read();
        lcc[i].first=lcc[i].last=lcc+i;
        lcc[i].size=1;
        lcc[i].x=lcc[i].sum=lcc[i].all=(Info){w[i],1,w[i]};
        lcc[i].sub=lcc[i].ex=NULL_INFO;
        lcc[i].chain_tag=lcc[i].sub_tag=lcc[i].ex_tag_sum=NULL_TAG;
    }
    _node_tot=lcc+n;
    return;
}
void work(){
    for(int i=1;i<=Q;i++){
        char ch=getchar();
        while(ch<=32) ch=getchar();
        if(ch=='l'){
            Pass_Pau(3);
            int u=read(),v=read(),len=read();
            puts(link(u,v,len) ? "ok" : "failed");
        }else if(ch=='c'){
            Pass_Pau(2);
            int u=read(),v=read(),len=read();
            puts(cut(u,v,len) ? "ok" : "failed");
        }else if(ch=='q'){
            Pass_Pau(4);
            ch=getchar();
            int u=read(),v=read();
            Info ret;
            ret=ch=='1' ? query_path(u,v) : query_subcactus(u,v);
            printf("%d %lld\n",ret.mi,ret.sum);
        }else if(ch=='a'){
            Pass_Pau(2);
            ch=getchar();
            int u=read(),v=read(),val=read();
            puts((ch=='1'?modify_path(u,v,val):modify_subcactus(u,v,val)) ? "ok" : "failed");
        }else puts("error");
    }
    return;
}
void print(){
    return;
}
int main(){init();work();print();return 0;}