hdu 4680 About set 小记（毕竟是一天的时光啊）

最新推荐文章于 2020-05-04 06:38:49 发布

haha593572013

最新推荐文章于 2020-05-04 06:38:49 发布

阅读量2.2k

点赞数 3

分类专栏： Data Structures Good Problems

本文链接：https://blog.csdn.net/crazy_ac/article/details/10013975

版权

Data Structures 同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

Good Problems

25 篇文章 0 订阅

订阅专栏

Problem Description

Today Zhanyl (sister Zhan as you know) receives a task about set operation. Although she is very good at this task,
but you know she is very lazy so that she wants you to help her write a program to complete this task. Surly
Zhanyl is able to solve this question, but you know, she is just lazy ...
Here is the problem, you are given n numbers, each number i has a value A _i, initially they are in different set.
Following there are m operations/querys.
The following is 5 possible kinds of oprations/querys:
1 u v: Union the set u belongs to and the set v belongs to.
2 u v: Delete u from its original set and add it to the set v belongs to.
3 u x: change the value of u to x. 1<=x<=10 ⁹
4 u: query how many numbers you can choose most in set which u belongs to, so no three numbers can form a triangle.
5 u l r: query the gcd of the numbers between [l,r] in the set u belongs to, if there is no number between [l,r],you can suppose the answer is -1. 1<=l<=r<=10⁹
Because Zhanyl is a good person, so she guarantee 1<=u,v<=n above.
You need to tell Zhanyl the answer to each query.

Input

The first line of the input is a single integer T which is the number of test cases.Then comes the T test cases .
For each test case, the first line contains two integer n and m, n is the number of set initially, m is the number
of operations/querys.
Following line contains n integers, A ₁, A ₂, ... , A _n, the value of i-th number.
Following m lines, each line is a operation or query.

Note that 1<=n,m<=10 ⁵, 1<=A _i<=10 ⁹

各种操作如上。

大裸数据结构啊，比赛的时候想敲的，不过很长时间没写这种多

颗树合并的题，而且有一个最关键的启发式合并的地方想歪了，认为复杂度不行，就没敲，现在想想还真是后悔，只怪自己的思维还不够严谨，要是在比赛中敲，不管能不能AC，都会比赛后敲来的激情啊。

好歹花了一天时间，第一次全部手写splay树的所有函数，debug的时候过于自信就没去看那几个函数，而且还过了自己出的很多数据，后来看到了，就一点点改，一直到所有的bug都找到了（我认为的），交上去还是TLE，比较庆幸的是这次写没有像写10天津那个题一样，RE了好长一排（那是第一次写指针splay），很多结构调试起来还是轻松的，但是由于种种细节过多，导致我一开始就看出来的错误有一个地方没有修改好，然后就一直T。。

一些花絮：：

TLE持续中。。。。。

实在是好忧桑啊。。。。。

这日子没法过了。。。。。

怎么办怎么办。。。。。。。。

继续埋头看代码。。。。。

找到了！！！！

再来一发，还是TLE。。。。。

MD，爆粗口了。。。。。

好吧，先去赚点钱吧！！！！都是正事啊。。。

教别人游泳的时候一直无法专心，，，，，明明没错啊，，，

晚上回到寝室，杰哥帮忙跑了一发100000的数据，竟然跑不出来。。

这不科学

然后仔细一看，有个地方写傻了，，，，

233333333333333333333333333333

我乃绝世大sb，不能直视啊。。。

然后怒交一发，AC了！！！！！！

这个题思路很简单的，就按照题目告诉的模拟就好了，真正好的数据结构题不该是这种大裸的题吧，，，

还是贴个代码吧。。。不过代码略微有些含蓄+混乱。。。切勿随意模仿

/* ********************************************** 
Author      : wuyiqi 
Created Time: 2013-8-16 8:24:44 
File Name   : hdu 4680.cpp 
 *********************************************** */  
#pragma comment(linker,"/STACK:100000000,100000000")  
#include <cstring>  
#include <cstdio>  
#include <string>  
#include <iostream>  
using namespace std;  
#define L x->c[0]  
#define R x->c[1]  
#define KT  root->c[1]->c[0]  
const int  maxn = 300010;  
const int lim = 1000000000;  
int GCD(int a,int b) {  
    if(a<0||a>lim) return b;  
    if(b<0||b>lim) return a;  
    return !b ? a : GCD(b,a%b);  
}  
struct node {  
    struct node *c[2] , *fa;  
    int id;  
    int sz;  
    int gcd;  
    int val;  
    int who;  
    bool d() {  
        return fa->c[0] == this;  
    }  
    void setc(int d,node *s) {  
        c[d] = s;  
        s->fa = this;  
    }  
    void up() {  
        sz = c[0]->sz + c[1]->sz + 1;  
        gcd = GCD(c[0]->gcd,c[1]->gcd);  
        gcd = GCD(gcd,val);  
    }  
    void clear(node *null) {  
        c[0] = c[1] = null;  
    }  
}NODE[maxn] , *null = &NODE[0];  
node* Q[maxn];  
node* ID[maxn];  
int Type;  
int n;  
int top;  
struct _x_x_{  
    int type;  
    node* root;  
    void Rotate(node *x,int f){  
        node *y = x->fa;  
        y->setc(!f,x->c[f]);  
        x->fa = y->fa;  
        if(y->fa != null) y->fa->setc(!y->d(),x);  
        x->setc(f,y);  
        y->up();  
    }  
    void Splay(node *x,node *goal) {  
        while(x->fa!=goal) {  
            if(x->fa->fa == goal) Rotate(x,x->d());  
            else {  
                int f = x->fa->d();  
                x->d() == f ? Rotate(x->fa,f) : Rotate(x,!f);  
                Rotate(x,f);  
            }  
        }  
        x->up();  
        if(goal == null)  {  
            root = x;  
        }  
    }  
    void RTO(int k,node *goal) {  
        node *x = root;  
        while(L->sz + 1 != k) {  
            if(k < L->sz + 1) x = L;  
            else {  
                k -= L->sz + 1;  
                x = R;  
            }  
        }  
        Splay(x,goal);  
    }  
    node* new_node(node *fa,int v) {  
        node *x = &NODE[++top];  
        x->id = top;  
        x->c[0] = x->c[1] = null;  
        x->sz = 1;  
        x->val = v;  
        x->gcd = v;  
        x->fa = fa;  
        ID[top] = x;  
        return x;  
    }  
    void init(int v) {  
        root = new_node(null,v);  
        type = ++Type;  
        root->who = type;  
    }  
    void Del_root() {  
        node *t = root;  
        if(t->c[1] != null) {  
            root = t->c[1];  
            RTO(1,null);  
            root->c[0] = t->c[0];  
            if(root->c[0] != null)   
                root->c[0]->fa = root;  
        } else  {  
            root = root->c[0];  
        }  
        root->fa = null;  
        if(root != null) root->up();  
    }  
    void Delete(node *x) {  
        Splay(x,null);  
        Del_root();  
    }  
    void Insert(node *x) {  
        x->clear(null);     //插入一个节点前不能忘记清空它的左右儿子  
        insert(root,x);  
        Splay(x,null);  
        x->who  = type;  
    }  
    void insert(node* &x,node *y) {  
        if(x == null) {  
            x = y;  
            return ;  
        }  
        if(y->val <= x->val) {  
            insert(x->c[0],y);  
            x->c[0]->fa = x;  
        } else {  
            insert(x->c[1],y);  
            x->c[1]->fa = x;  
        }  
        x->up();  
    }  
    void Change(int u,int v) {  
        node *tmp = ID[u+2*n];  
        Splay(tmp,null);  
        Del_root();  
        tmp->val = v;  
        Insert(tmp);  
    }  
    node *find_succ(node *x,int v) {  // equal or bigger than v
        if(x == null) return x;  
        if(x->val == v) return x;  
        else if(x->val > v) {  
            node *tmp = find_succ(x->c[0],v);  
            return tmp == null ? x : tmp;  
        }else {  
            return find_succ(x->c[1],v);  
        }  
    }  
    node *find_pre(node *x,int v) {  // strictly less than v
        if(x == null) return x;  
        if(x->val < v) {  
            node *tmp = find_pre(x->c[1],v);  
            return tmp == null ? x : tmp;  
        } else {  
            return find_pre(x->c[0],v);  
        }  
    }  
    int Gao() {  
        if(root->sz <= 4)  return root->sz - 2;  
        RTO(2,null);  
        int a = root->val;  
        RTO(3,null);  
        int b = root->val;  
        int ans = 2;  
        while(true){  
            if(a + b > lim) break;  
            int c = find_succ(root,a+b)->val;  
            if(c > lim || c == -1) break;  
            a = b; b = c;  
            ans++;  
        }  
        return ans;  
    }  
    int Solve(int l,int r) {  
        node *pre = find_pre(root,l);  
        node *succ = find_succ(root,r+1);  
        Splay(pre,null);  
        Splay(succ,root);  
        return KT->gcd;  
    }  
    void Merge(_x_x_ &tree) {  
        int head = 0, tail = 0;  
        tree.RTO(1,null);  
        tree.RTO(tree.root->sz,tree.root);  
        Q[++tail] = tree.KT;  
        while(head < tail) {  
            node *fr = Q[++head];  
            if(fr->c[0] != null) Q[++tail] = fr->c[0];  
            if(fr->c[1] != null) Q[++tail] = fr->c[1];  
            Insert(fr);//此处吐血了一整天，上面的改回来了，这里却没改insert(root,fr);  
            fr->who = type;  
        }  
        tree.KT = null;  
        tree.root->c[1]->up();  
        tree.root->up();  
    }  
}spt[maxn];  
void prepare() {  
    null->id = 0;  
    null->c[0] = null->c[1] = null->fa = NULL;  
    null->sz = null->val = 0;  
    null->gcd = -1;  
    Type = 0;  
    top = 0;  
}  
int main()  
{  
    int t,m,ca=1,op,u,v,l,r,x;  
    scanf("%d",&t);  
    while(t--) {  
        prepare();  
        scanf("%d%d",&n,&m);  
        for(int i = 1; i <= n; i++){  
            spt[i].init(-1);  
            node *tmp =  spt[i].new_node(null,lim+1);
            spt[i].Insert(tmp);  
        }  
        for(int i = 1,a; i <= n; i++) {  
            scanf("%d",&a);  
            node *tmp = spt[i].new_node(null,a);
            spt[i].Insert(tmp);  
        }  
        int tot = 0;  
        printf("Case #%d:\n",ca++);  
        while(m--) {  
            scanf("%d",&op);  
            if(op == 1) {  
                scanf("%d%d",&u,&v);   
                node *tmp1 = ID[u+2*n] , *tmp2 = ID[v+2*n];  
                int tree1 = tmp1->who;  
                int tree2 = tmp2->who;  
                if(tree1 == tree2) continue;  
                int sz1 = spt[tree1].root->sz;  
                int sz2 = spt[tree2].root->sz;  
                if(sz1 > sz2) {  
                    spt[tree1].Merge(spt[tree2]);  
                } else {  
                    spt[tree2].Merge(spt[tree1]);  
                }  
            } else if(op == 2) {  
                scanf("%d%d",&u,&v);  
                node *tmp1 = ID[u+2*n] , *tmp2 = ID[v+2*n];  
                int tree1 = tmp1->who;  
                int tree2 = tmp2->who;  
                spt[tree1].Delete(tmp1);  
                spt[tree2].Insert(tmp1);  
            } else if(op == 3) {  
                scanf("%d%d",&u,&x);  
                node *tmp = ID[u+2*n];  
                int tree = tmp->who;  
                spt[tree].Change(u,x);  
            }  else if(op == 4) {  
                scanf("%d",&u);  
                node *tmp = ID[u+2*n];  
                int tree = tmp->who;  
                printf("%d\n",spt[tree].Gao());  
            } else {  
                scanf("%d%d%d",&u,&l,&r);  
                node *tmp = ID[u+2*n];  
                int tree = tmp->who;  
                printf("%d\n",spt[tree].Solve(l,r));  
            }  
        }  
    }  
    return 0;  
}