数据结构整理

今天实在是太颓了……前几天把自己认为的可做题写完了，现在刷题列表里只剩下了一些自己不(xia)愿(ji)意(ba)写(zhao)的毒瘤题了，实在不愿意做……

于是整个上午睡觉，然后发现自己连水题都不愿意写了……
还是来整理一下这些天写过的题目吧……

 

Bzoj3123:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=3123

首先这题如果不强制在线，我们把这棵树建出来然后主席树乱搞一下就好了(皮这一下很开心吗?)

然后考虑在线怎么做，我们可以按秩合并，也就多一个log罢了，于是我们得到了一个优秀的nlog^2n做法:每次把较小的联通块的主席树扔掉，然后重建即可。

其余的细节?就是顺便用倍增维护一下LCA，用并查集维护一下联通块size就好了。

关于GC(垃圾回收):我写的有0号点作为空树的主席树是没法GC的，只能二分数组大小然后卡过。这个我也问过梁大爷，如果不用0号树，直接用0号点做所有空节点的话，是可以GC的。话说这题时限本来就卡，写了GC不就是TLE(雾)。

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define debug cout
using namespace std;
const int maxn=8e4+1e2,maxl=20;
 
struct ChairmanTree {
    int l[maxn*200],r[maxn*200],lson[maxn*200],rson[maxn*200],sum[maxn*200],cnt;
    inline int NewNode() {
        return ++cnt;
    }
    inline void build(int pos,int ll,int rr) {
        l[pos] = ll , r[pos] = rr;
        if( ll == rr ) return;
        const int mid = ( ll + rr ) >> 1;
        build(lson[pos]=NewNode(),ll,mid);
        build(rson[pos]=NewNode(),mid+1,rr);
    }
    inline void insert(int pos,int pre,int x) {
        l[pos] = l[pre] , r[pos] = r[pre] ,
        lson[pos] = lson[pre] , rson[pos] = rson[pre];
        if( l[pos] == r[pos] ) {
            sum[pos] = sum[pre] + 1;
            return;
        } const int mid = ( l[pos] + r[pos] ) >> 1;
        if( x <= mid ) insert(lson[pos]=NewNode(),lson[pre],x);
        else insert(rson[pos]=NewNode(),rson[pre],x);
        sum[pos] = sum[lson[pos]] + sum[rson[pos]];
    }
    inline int cl(int a1,int a2,int b1,int b2) {
        return sum[lson[a1]] + sum[lson[a2]] - sum[lson[b1]] - sum[lson[b2]];
    }
    inline int query(int a1,int a2,int b1,int b2,int k) {
        if( l[a1] == r[a1] ) return l[a1];
        int sl = cl(a1,a2,b1,b2);
        if( k <= sl ) return query(lson[a1],lson[a2],lson[b1],lson[b2],k);
        return query(rson[a1],rson[a2],rson[b1],rson[b2],k-sl);
    }
}tr;
struct UnionFindSet {
    int fa[maxn],siz[maxn];
    inline int findfa(int x) {
        if( fa[x] == x ) return x;
        siz[fa[x]] += siz[x] , siz[x] = 0;
        return fa[x] = findfa(fa[x]);
    }
    inline int getsiz(int x) {
        return siz[findfa(x)];
    }
    inline void merge(int x,int y) {
        x = findfa(x) , y = findfa(y);
        siz[x] += siz[y] , siz[y] = 0;
        fa[y] = x;
    }
    inline void init(int n) {
        for(int i=1;i<=n;i++) fa[i] = i , siz[i] = 1;
    }
}ufs;
 
int in[maxn],srt[maxn],slen;
int s[maxn],t[maxn<<2],nxt[maxn<<2],cnt;
int fa[maxn][maxl],root[maxn],dep[maxn];
int n;
 
inline void addedge(int from,int to) {
    t[++cnt] = to , nxt[cnt] = s[from] , s[from] = cnt;
}
inline void recycle(int pos) {
    for(int at=s[pos];at;at=nxt[at])
        if( t[at] != fa[pos][0] )
            recycle(t[at]);
    memset(fa[pos],0,sizeof(fa[pos]));
}
inline void build(int pos) {
    root[pos] = tr.NewNode();
    tr.insert(root[pos],root[fa[pos][0]],in[pos]);
    for(int i=1;i<maxl;i++) fa[pos][i] = fa[fa[pos][i-1]][i-1];
    for(int at=s[pos];at;at=nxt[at])
        if( t[at] != fa[pos][0] ) {
            fa[t[at]][0] = pos , dep[t[at]] = dep[pos] + 1;
            build(t[at]);
        }
}
inline int lca(int x,int y) {
    if( dep[x] < dep[y] ) swap(x,y);
    for(int i=maxl-1;~i;i--)
        if( dep[x] - dep[y] >= ( 1 << i ) )
            x = fa[x][i];
    if( x == y ) return x;
    for(int i=maxl-1;~i;i--)
        if( fa[x][i] != fa[y][i] )
            x = fa[x][i] , y = fa[y][i];
    return fa[x][0];
}
inline int getroot(int x) {
    for(int i=maxl-1;~i;i--)
        if( fa[x][i] )
            x = fa[x][i];
    return x;
}
inline int kth(int x,int y,int k) {
    int l = lca(x,y) , f = fa[l][0];
    return tr.query(root[x],root[y],root[l],root[f],k);
}
inline void merge(int x,int y) {
    int sx = ufs.getsiz(x) , sy = ufs.getsiz(y);
    if( sx < sy ) swap(x,y);
    recycle(getroot(y));
    ufs.merge(x,y);
    addedge(x,y) , addedge(y,x);
    fa[y][0] = x , dep[y] = dep[x] + 1;
    build(y);
}
 
inline void init() {
    memcpy(srt+1,in+1,sizeof(int)*n);
    sort(srt+1,srt+1+n) , slen = unique(srt+1,srt+1+n) - srt - 1;
    for(int i=1;i<=n;i++) in[i] = lower_bound(srt+1,srt+1+slen,in[i]) - srt;
    root[0] = tr.NewNode();
    tr.build(root[0],1,slen);
    ufs.init(n);
    for(int i=1;i<=n;i++)
        if( !root[i] ) build(i);
    for(int i=1;i<=n;i++)
        if( fa[i][0] ) ufs.merge(fa[i][0],i);
}
 
int main() {
    static int m,os,la;
    static char o[10];
    scanf("%*d%d%d%d",&n,&m,&os) , la = 0;
    for(int i=1;i<=n;i++) scanf("%d",in+i);
    for(int i=1,a,b;i<=m;i++) {
        scanf("%d%d",&a,&b);
        addedge(a,b) , addedge(b,a);
    }
    init();
    for(int i=1,x,y,k;i<=os;i++) {
        scanf("%s%d%d",o,&x,&y) , x ^= la , y ^= la;
        if( *o == 'Q' ) {
            scanf("%d",&k) , k ^= la;
            la = kth(x,y,k);
            la = srt[la];
            printf("%d\n",la);
        } else {
            merge(x,y);
        }
    }
    return 0;
}

 

Bzoj1453:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=1453

各位大佬看来这不是LCT水题吗?或者cdq+并查集乱搞一下。

然而为什么我一开始想到的是n^2m的暴力?

考虑暴力怎么优化?如果我们把一维建成线段树，另一位继续暴力，是不是就能卡过去了呢?

我们在线段树的每个节点上维护区间左边一列位置，右边一列位置，左边一列的id，右边一列的id，每个id是否出现在左、右，区间内的黑色、白色联通块数，然后合并一下就可以了。

关于这玩意怎么合并？我们考虑用并查集维护每个格子属于哪个集合。我们先把右区间的id全部加400的偏移量，然后让左区间的右和右区间的左去合并。合并完成后统计合并失败后被封锁(无法接触左右边界)的黑白联通块数并更新答案，然后重新离散化id并维护每个id在左右是否出现了。

这题复杂度不怎么卡，常数写的很丑也给过了QAQ。

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=2e2+1e1,maxl=8e2+1e1;
 
int in[maxn][maxn],tp[maxl];
int n;
 
struct UnionFindSet {
    int fa[maxl];
    inline int findfa(int x) {
        return fa[x] == x ? x : fa[x] = findfa(fa[x]);
    }
    inline void merge(int x,int y) {
        x = findfa(x) , y = findfa(y);
        if( x != y ) fa[x] = y;
    }
    inline void resfa(int k) {
        for(int i=1;i<=k;i++) fa[i] = i;
    }
}ufs;
 
struct Node {
    int fal[maxn],far[maxn],sta[maxn<<1],l,r,inb,inw; // sta means a number's appear place .
    Node() {
        memset(fal,0,sizeof(fal));
        memset(far,0,sizeof(far));
        memset(sta,0,sizeof(sta));
        l = r = inb = inw = 0;
    }
    inline void rebuild() {
        static int cov[maxl] , cnt;
        memset(cov,0,sizeof(cov)) , cnt = 0;
        for(int i=1;i<=n;i++) if( !cov[fal[i]] ) cov[fal[i]] = ++cnt;
        for(int i=1;i<=n;i++) if( !cov[far[i]] ) cov[far[i]] = ++cnt;
        for(int i=1;i<=n;i++) fal[i] = cov[fal[i]] , sta[fal[i]] |= 1; // 1 means appeared on left .
        for(int i=1;i<=n;i++) far[i] = cov[far[i]] , sta[far[i]] |= 2; // 2 means appeared on right .
    }
    inline void getfa() {
        for(int i=1;i<=n;i++) fal[i] = ufs.findfa(fal[i]) , far[i] = ufs.findfa(far[i]);
    }
    friend Node operator + (const Node &a,const Node &fakeb) { // we have to operate b.
        Node ret,b=fakeb;
        ret.l = a.l , ret.r = b.r , ret.inb = a.inb + b.inb , ret.inw = a.inw + b.inw;
        int mil = a.r , mir = b.l;
        ufs.resfa(n<<2) , memset(tp,0,sizeof(tp));
        for(int i=1;i<=n;i++)
            b.fal[i] += n<<1 , b.far[i] += n<<1;
        memcpy(ret.fal,a.fal,sizeof(a.fal)) , memcpy(ret.far,b.far,sizeof(b.far));
        for(int i=1;i<=n;i++)
            if( in[i][mil] == in[i][mir] ) ufs.merge(a.far[i],b.fal[i]);
        for(int i=1;i<=n;i++)
            tp[ufs.findfa(ret.fal[i])] |= 1 , tp[ufs.findfa(ret.far[i])] |= 2;
        for(int i=1;i<=n;i++) {
            if( !tp[ufs.findfa(a.far[i])] ) {
                tp[ufs.findfa(a.far[i])] = 4;
                if( in[i][mil] == 0 ) ++ret.inw;
                else ++ret.inb;
            }
            if( !tp[ufs.findfa(b.fal[i])] ) {
                tp[ufs.findfa(b.fal[i])] = 4;
                if( in[i][mir] == 0 ) ++ret.inw;
                else ++ret.inb;
            }
        }
        ret.getfa() , ret.rebuild();
        return ret;       
    }
    inline void set(int p) {
        l = r = p , inb = inw = 0;
        int c = 0;
        for(int i=1;i<=n;i++) {
            if( i == 1 || in[i][p] != in[i-1][p] ) fal[i] = far[i] = ++c , sta[c] = 3;
            else fal[i] = far[i] = fal[i-1];
        }
    }
    inline void count(int& retb,int& retw) {
        static bool vis[maxn<<1];
        memset(vis,0,sizeof(vis));
        retb = inb , retw = inw;
        for(int i=1;i<=n;i++)
            if( !vis[fal[i]] ) {
                vis[fal[i]] = 1;
                if( in[i][l] == 0 ) ++retw;
                else ++retb;
            }
        for(int i=1;i<=n;i++)
            if( !vis[far[i]] ) {
                vis[far[i]] = 1;
                if( in[i][r] == 0 ) ++retw;
                else ++retb;
            }
    }
}ns[maxn<<3];
 
int l[maxn<<3],r[maxn<<3],lson[maxn<<3],rson[maxn<<3],cnt;
 
inline void build(int pos,int ll,int rr) {
    l[pos] = ll , r[pos] = rr;
    if( ll == rr ) {
        ns[pos].set(ll);
        return;
    } const int mid = ( ll + rr ) >> 1;
    build(lson[pos]=++cnt,ll,mid) , build(rson[pos]=++cnt,mid+1,rr);
    ns[pos] = ns[lson[pos]] + ns[rson[pos]];
}
inline void update(int pos,int tar) {
    if( tar < l[pos] || r[pos] < tar ) return;
    if( l[pos] == r[pos] ) {
        ns[pos].set(l[pos]);
        return;
    }
    update(lson[pos],tar) , update(rson[pos],tar);
    ns[pos] = ns[lson[pos]] + ns[rson[pos]];
}
 
inline void printans() {
    static int ab,aw;
    ns[1].count(ab,aw);
    printf("%d %d\n",ab,aw);
}
int main() {
    static int m;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",in[i]+j);
    build(cnt=1,1,n);
    scanf("%d",&m);
    for(int i=1,x,y;i<=m;i++) {
        scanf("%d%d",&x,&y);
        in[x][y] = !in[x][y];
        update(1,y);
        printans();
    }
    return 0;
}

 

 

Bzoj3796:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=3786

这真不是LCT水题?等等，子树加，LCT做不了。

考虑用DFS序解决子树加的问题，关于子树加，就是区间加。关于更换父亲?就是区间移动喽。

对于区间移动，就是先提取区间，然后把他放到新的父亲的右边的第一个位置即可。

如果你懒得加哨兵节点，代码细节较多注意讨论。

代码:

 
#pragma GCC optimize(3)
#include<cstdio>
#include<cctype>
#define lli long long int
const int maxn=2e5+1e2;
 
int st,ed;
 
struct Splay {
    int ch[maxn][2],fa[maxn],tpe[maxn],siz[maxn],cnt,root;
    lli sum[maxn],dat[maxn],lazy[maxn];
     
    inline void set(int pos,lli add) {
        if( !pos ) return;
        dat[pos] += tpe[pos] * add , sum[pos] += siz[pos] * add , lazy[pos] += add;
    }
    inline void push(int pos) {
        if( !lazy[pos] ) return;
        set(ch[pos][0],lazy[pos]) ,
        set(ch[pos][1],lazy[pos]) ,
        lazy[pos] = 0;
    }
    inline void up(int fa,int son) {
        if( !son ) return;
        siz[fa] += siz[son] , sum[fa] += sum[son];
    }
    inline void upgrade(int pos) {
        siz[pos] = tpe[pos] , sum[pos] = dat[pos];
        up(pos,ch[pos][0]) ,
        up(pos,ch[pos][1]) ;
    }
    inline int gid(int x) {
        return x == ch[fa[x]][1];
    }
    inline void rotate(int x) {
        const int f = fa[x] , id = gid(x);
        push(f) , push(x);
        fa[x] = fa[f];
        if( fa[f] ) ch[fa[f]][gid(f)] = x;
        else root = x;
        ch[f][id] = ch[x][id^1];
        if( ch[x][id^1] ) fa[ch[x][id^1]] = f;
        ch[x][id^1] = f , fa[f] = x;
        upgrade(f) , upgrade(x);
    }
    inline void splay(int pos) {
        while( pos != root ) {
            if( fa[fa[pos]] ) rotate(fa[pos]);
            rotate(pos);
        }
    }
    inline void upchain(int pos) {
        while( pos != root ) {
            upgrade(pos) , pos = fa[pos];
        }
    }
    inline int insert(int tp,int va) {
        if( !root ) {
            root = ++cnt , tpe[root] = tp , sum[root] = dat[root] = tp * va;
            return root;
        }
        int ret = ++cnt , now = root;
        tpe[ret] = tp , sum[ret] = dat[ret] = tp * va;
        while( ch[now][1] ) now = ch[now][1];
        ch[now][1] = ret , fa[ret] = now;
        upchain(ret);
        splay(ret);
        return ret;
    }
    inline void mkrson(int pos) {
        while( pos != ch[root][1] ) {
            if( fa[pos] != ch[root][1] ) rotate(fa[pos]);
            rotate(pos);
        }
    }
    inline void pushchain(int pos) {
        if( pos != root ) pushchain(fa[pos]);
        push(pos);
    }
    inline int getprv(int pos) {
        if( pos == st ) return -1;
        if( ch[pos][0] ) {
            int ret = ch[pos][0];
            while( ch[ret][1] ) ret = ch[ret][1];
            return ret;
        }
        while( pos == ch[fa[pos]][0] ) pos = fa[pos];
        return fa[pos];
    }
    inline int getnxt(int pos) {
        if( pos == ed ) return -1;
        if( ch[pos][1] ) {
            int ret = ch[pos][1];
            while( ch[ret][0] ) ret = ch[ret][0];
            return ret;
        }
        while( pos == ch[fa[pos]][1] ) pos = fa[pos];
        return fa[pos];
    }
    inline void update(int posl,int posr,lli add) {
        int prv = getprv(posl) , nxt = getnxt(posr);
        if( !~prv && !~nxt ) {
            set(root,add);
            return;
        }
        splay(prv) , mkrson(nxt);
        int pos = ch[ch[root][1]][0];
        set(pos,add);
        splay(pos);
    }
    inline int segment(int posl,int posr) { // assert posl != in[1] && posr != out[1] .
        int prv = getprv(posl) , nxt = getnxt(posr);
        splay(prv) , mkrson(nxt);
        return ch[ch[root][1]][0];
    }
    inline void move(int posl,int posr,int nfa) {
        int pos = segment(posl,posr);
        pushchain(fa[pos]);
        ch[fa[pos]][gid(pos)] = 0 , fa[pos] = 0;
        splay(nfa);
        int tar = ch[nfa][1];
        while( ch[tar][0] ) tar = ch[tar][0];
        pushchain(tar);
        ch[tar][0] = pos , fa[pos] = tar;
        splay(pos);
    }
    inline lli query(int pos) {
        int nxt = getnxt(pos);
        splay(nxt);
        return sum[ch[root][0]];
    }
}T;
 
int s[maxn>>1],t[maxn],nxt[maxn];
int in[maxn>>1],out[maxn>>1];
int w[maxn>>1];
 
inline void addedge(int from,int to) {
    static int cnt = 0;
    t[++cnt] = to , nxt[cnt] = s[from] , s[from] = cnt;
}
inline void dfs(int pos) {
    in[pos] = T.insert(1,w[pos]);
    for(int at=s[pos];at;at=nxt[at])
        dfs(t[at]);
    out[pos] = T.insert(-1,w[pos]);
}
 
inline char nextchar() {
    const static int BS = 1 << 21;
    static char buf[BS],*st=buf+BS,*ed=buf+BS;
    if( st == ed ) ed = buf + fread(st=buf,1,BS,stdin);
    return st == ed ? -1 : *st++;
}
inline int getint() {
    int ret = 0 , ch;
    while( !isdigit(ch=nextchar()) );
    do ret=ret*10+ch-'0'; while( isdigit(ch=nextchar()) );
    return ret;
}
inline char realchar() {
    char ret;
    while( !isalpha(ret=nextchar()) ) ;
    return ret;
}
int main() {
    static int n,m;
    static char o;
    n = getint();
    for(int i=2,f;i<=n;i++) {
        f = getint();
        addedge(f,i);
    }
    for(int i=1;i<=n;i++) w[i] = getint();
    dfs(1) , st = in[1] , ed = out[1];
    m = getint();
    for(int i=1,p,x;i<=m;i++) {
        o = realchar() , p = getint();
        if( o == 'Q' ) printf("%lld\n",T.query(in[p]));
        else {
            x = getint();
            if( o == 'F' ) T.update(in[p],out[p],x);
            else T.move(in[p],out[p],in[x]);
        }
    }
    return 0;
}

 

 

Bzoj1493:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=1493

前两个操作可以写用变量维护，然后线段树可做，细节较多。

好的，细节太多?我选择splay。

Rotate就是把区间最后一段移动到最前，Filp就是把区间[2,n]翻转。

然后swap看做两个单点的区间染色，我们只需要实现区间染色，统计区间颜色数量就可以了。

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=5e5+1e2;
 
int n;
 
struct Splay {
    int ch[maxn][2],fa[maxn],col[maxn][2],dat[maxn],sum[maxn],siz[maxn],root,cnt; // sum includes color on sides .
    int rev[maxn],recol[maxn]; // rev >= recol , so you must push recol first before pusing rev .
     
    Splay() {
        memset(recol,-1,sizeof(recol));
    }
    inline void fill(int pos,int cc) {
        if( !pos ) return;
        col[pos][0] = col[pos][1] = dat[pos] = recol[pos] = cc , sum[pos] = 1;
    }
    inline void initfill(int pos,int cc) {
        col[pos][0] = col[pos][1] = dat[pos] = cc , sum[pos] = 1;
    }
    inline void applyrev(int pos) {
        if( !pos ) return;
        swap( ch[pos][0] , ch[pos][1] ) , swap( col[pos][0] , col[pos][1] );
    }
    inline void push(int pos) {
        if( ~recol[pos] ) {
            fill(ch[pos][0],recol[pos]) , fill(ch[pos][1],recol[pos]);
            recol[pos] = -1;
        }
        if( rev[pos] ) {
            rev[ch[pos][0]] ^= 1 , rev[ch[pos][1]] ^= 1;
            applyrev(ch[pos][0]) , applyrev(ch[pos][1]);
            rev[pos] = 0;
        }
    }
    inline void upgrade(int pos) {
        col[pos][0] = col[pos][1] = dat[pos] , sum[pos] = 1 ,
        siz[pos] = 1;
        if( ch[pos][0] ) {
            sum[pos] = sum[pos] + sum[ch[pos][0]] - ( col[ch[pos][0]][1] == col[pos][0] ) , 
            col[pos][0] = col[ch[pos][0]][0] ,
            siz[pos] += siz[ch[pos][0]] ;
        }
        if( ch[pos][1] ) {
            sum[pos] = sum[pos] + sum[ch[pos][1]] - ( col[pos][1] == col[ch[pos][1]][0] ) ,
            col[pos][1] = col[ch[pos][1]][1]  ,
            siz[pos] += siz[ch[pos][1]] ;
        }
    }
    inline int gid(int x) {
        return x == ch[fa[x]][1];
    }
    inline void rotate(int x) {
        push(fa[x]) , push(x);
        const int f = fa[x] , id = gid(x);
        fa[x] = fa[f];
        if( fa[f] ) ch[fa[f]][gid(f)] = x;
        else root = x;
        ch[f][id] = ch[x][id^1];
        if( ch[x][id^1] ) fa[ch[x][id^1]] = f;
        ch[x][id^1] = f , fa[f] = x;
        upgrade(f) , upgrade(x);
    }
    inline void splay(int pos) {
        while( root != pos ) {
            if( fa[fa[pos]] ) rotate(fa[pos]);
            rotate(pos);
        }
    }
    inline void upchain(int x) {
        while( x ) {
            upgrade(x) , 
            x = fa[x];
        }
    }
    inline void pushchain(int x) {
        if( fa[x] ) pushchain(fa[x]);
        push(x);
    }
    inline void insert(int cc) {
        if( !root ) {
            root = ++cnt , siz[cnt] = 1;
            initfill(root,cc);
            return;
        }
        int now = root;
        while( push(now) , ch[now][1] ) now = ch[now][1];
        ch[now][1] = ++cnt , siz[cnt] = 1 , fa[cnt] = now;
        initfill(cnt,cc) , upchain(cnt);
        splay(cnt);
    }
    inline int kth(int k) {
        int now = root;
        while( 1 ) {
            push(now);
            if( k < 0 ) exit(0);
            if( k == siz[ch[now][0]] + 1 ) return now;
            if( k <= siz[ch[now][0]] ) now = ch[now][0];
            else k -= siz[ch[now][0]] + 1 , now = ch[now][1];
        }
        throw "It Shouldn't Be Here ." ; 
    }
    inline void insertleft(int pos) {
        int now = root;
        while( push(now) , ch[now][0] ) now = ch[now][0];
        ch[now][0] = pos , fa[pos] = now;
        upchain(now);
    }
    inline void move(int k) {
        int mip = kth(n-k);
        splay(mip) , pushchain(mip);
        int pos = ch[mip][1]; ch[mip][1] = fa[pos] = 0;
        upchain(mip);
        insertleft(pos);
        splay(pos);
    }
    inline void filp() {
        int tar = kth(1);
        splay(tar);
        rev[ch[tar][1]] ^= 1 , applyrev(ch[tar][1]);
        splay(ch[tar][1]);
    }
    inline int getp(int k) {
        int pos = kth(k);
        return dat[pos];
    }
    inline void mkrson(int pos) {
        while( pos != ch[root][1] ) {
            if( fa[pos] != ch[root][1] ) rotate(fa[pos]);
            rotate(pos);
        }
    }
    inline void print(int st,int ed,int cc) {
        if( st == 1 && ed == n ) {
            fill(root,cc);
        } else if( st == 1 ) {
            int nxt = kth(ed+1);
            splay(nxt);
            fill(ch[root][0],cc);
            splay(ch[root][0]);
        } else if( ed == n ) {
            int prv = kth(st-1);
            splay(prv);
            fill(ch[root][1],cc);
            splay(ch[root][1]);
        } else {
            int nxt = kth(ed+1) , prv = kth(st-1);
            splay(prv) , mkrson(nxt);
            fill(ch[ch[root][1]][0],cc);
            splay(ch[ch[root][1]][0]);
        }
    }
    inline int count(int st,int ed) {
        if( st == 1 && ed == n ) {
            return max ( sum[root] - ( col[root][0] == col[root][1] ) , 1 );
        } else if( st == 1 ) {
            int nxt = kth(ed+1);
            splay(nxt);
            return sum[ch[root][0]];
        } else if( ed == n ) {
            int prv = kth(st-1);
            splay(prv);
            return sum[ch[root][1]];
        } else {
            int nxt = kth(ed+1) , prv = kth(st-1);
            splay(prv) , mkrson(nxt);
            return sum[ch[ch[root][1]][0]];
        }
    }
    inline int count(int st,int ed,int& rc) {
        if( st == 1 ) {
            int nxt = kth(ed+1);
            splay(nxt) , rc = col[ch[root][0]][0];
            return sum[ch[root][0]];
        } else if( ed == n ) {
            int prv = kth(st-1);
            splay(prv) , rc = col[ch[root][1]][1];
            return sum[ch[root][1]];
        }
        throw "It Shouldn't Be Here ." ; 
    }
}T;
 
int main() {
    static int m;
    static char o[10];
    scanf("%d%*d",&n);
    for(int i=1,x;i<=n;i++) {
        scanf("%d",&x);
        T.insert(x);
    }
     
    scanf("%d",&m);
    for(int i=1,x,y,k;i<=m;i++) {
        scanf("%s",o);
        if( *o == 'F' ) T.filp();
        else if( *o == 'C' ) {
            if( o[1] != 'S' ) printf("%d\n",T.count(1,n));
            else {
                scanf("%d%d",&x,&y);
                if( x <= y ) printf("%d\n",T.count(x,y));
                else {
                    int cx,cy,ans;
                    ans = T.count(x,n,cx) + T.count(1,y,cy);
                    ans -= ( cx == cy );
                    printf("%d\n",ans);
                }
            }
        } else {
            if( *o == 'R' ) {
                scanf("%d",&k);
                T.move(k);
            } else {
                scanf("%d%d",&x,&y);
                if( *o == 'S' ) {
                    int cx = T.getp(x) , cy = T.getp(y);
                    T.print(x,x,cy) , T.print(y,y,cx);
                } else {
                    scanf("%d",&k);
                    if( x <= y ) T.print(x,y,k);
                    else T.print(x,n,k) , T.print(1,y,k);
                }
            }
        }
    }
    return 0;
}

 

 

Bzoj2594:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=2594

把自始至终一直存在的边先求最小生成树放进去，我们倒序考虑，就是不断加边维护最小生成树了。

LCT没法维护边权，拆边为点，维护点权就好了。

写太丑会T，叫你写快读你非得scanf。

代码:

#pragma GCC optimize(2)
#include<cstdio>
#include<algorithm>
#include<cctype>
const int maxn=1e5+1e2,maxm=1e6+1e2,maxp=1.2e6+1e2;
 
int n,m,q;
struct LCT {
    int ch[maxp][2],fa[maxp],v[maxp],mx[maxp],rev[maxp];
     
    inline void applyrev(int pos) {
        if( !pos ) return;
        rev[pos] ^= 1 ,
        std::swap(ch[pos][0],ch[pos][1]);
    }
    inline void update(int pos) {
        mx[pos] = pos;
        if( v[mx[ch[pos][0]]] > v[mx[pos]] ) mx[pos] = mx[ch[pos][0]];
        if( v[mx[ch[pos][1]]] > v[mx[pos]] ) mx[pos] = mx[ch[pos][1]];
    }
    inline void push(int pos) {
        if( !rev[pos] ) return;
        applyrev(ch[pos][0]) ,
        applyrev(ch[pos][1]) ,
        rev[pos] = 0;
    }
    inline int gid(int x) {
        return x == ch[fa[x]][1];
    }
    inline bool isroot(int x) {
        return x != ch[fa[x]][0] && x != ch[fa[x]][1];
    }
    inline void rotate(int x) {
        push(fa[x]) , push(x);
        const int f = fa[x] , id = gid(x);
        fa[x] = fa[f];
        if( !isroot(f) ) ch[fa[f]][gid(f)] = x;
        ch[f][id] = ch[x][id^1];
        if( ch[x][id^1] ) fa[ch[x][id^1]] = f;
        ch[x][id^1] = f , fa[f] = x;
        update(f) , update(x);
    }
    inline void pushchain(int x) {
        if( fa[x] ) pushchain(fa[x]);
        push(x);
    }
    inline void splay(int x) {
        pushchain(x);
        while( !isroot(x) ) {
            if( !isroot(fa[x]) ) rotate(fa[x]);
            rotate(x);
        }
    }
    inline void access(int x) {
        int y = 0;
        while( x ) {
            splay(x) , ch[x][1] = y , update(x) ,
            y = x , x = fa[x];
        }
    }
    inline void mkroot(int x) {
        access(x) , splay(x) , applyrev(x);
    }
    inline void link(int x,int y) {
        mkroot(x) , fa[x] = y;
    }
    inline void cut(int x,int y) {
        mkroot(x);
        access(y) , splay(y);
        fa[x] = ch[y][0] = 0 , update(y); // now we assert x == ch[y][0] ( it must be true ) .
    }
    inline int query(int x,int y) {
        mkroot(x);
        access(y) , splay(y);
        return mx[y]; // y shouldn't have ch[1] .
    }
}t;
 
struct UnionFindSet {
    int fa[maxn];
    inline int findfa(int x) {
        return fa[x] == x ? x : fa[x] = findfa(fa[x]);
    }
    inline void merge(int x,int y) {
        x = findfa(x) , y = findfa(y);
        if( x != y ) fa[y] = x;
    }
    inline void init() {
        for(int i=1;i<=n;i++) fa[i] = i;
    }
}ufs;
 
struct Edge {
    int x,y,w,id,sta;
    friend bool operator < (const Edge &a,const Edge &b) {
        return a.x != b.x ? a.x < b.x : a.y < b.y;
    }
}es[maxm];
bool cmp(const Edge &a,const Edge &b) {
    return a.w < b.w;
}
 
int ope[maxn],x[maxn],y[maxn],id[maxn],ans[maxn]; // ope == 1 means modify .
 
inline void getans() {
    for(int i=q;i;i--) {
        if( !ope[i] ) {
            int p = t.query(x[i],y[i]);
            ans[i] = t.v[p];
        } else {
            if( ufs.findfa(x[i]) != ufs.findfa(y[i]) ) {
                ufs.merge(x[i],y[i]);
                t.link(x[i],id[i]+n) , t.link(y[i],id[i]+n);
            } else {
                int p = t.query(x[i],y[i]);
                if( t.v[p] > t.v[id[i]+n] ) {
                    t.cut(x[i],p) , t.cut(y[i],p);
                    t.link(x[i],id[i]+n) , t.link(y[i],id[i]+n);
                }
            }
        }
    }
}
inline void pre() {
    std::sort(es+1,es+1+m,cmp) , ufs.init();
    for(int i=1;i<=m;i++)
        if( !es[i].sta && ufs.findfa(es[i].x) != ufs.findfa(es[i].y) ) {
            ufs.merge(es[i].x,es[i].y);
            t.link(es[i].x,es[i].id+n) , t.link(es[i].y,es[i].id+n);
        }
}
 
inline void init() {
    for(int i=1;i<=m;i++) {
        const int id = i + n;
        t.v[id] = es[i].w , t.mx[id] = id;
    }
    std::sort(es+1,es+1+m);
    for(int i=1;i<=q;i++) 
        if( ope[i] ) {
            int at = std::lower_bound(es+1,es+1+m,(Edge){x[i],y[i],0,0,0}) - es;
            es[at].sta = 1 , id[i] = es[at].id;
        }
}
 
inline char nextchar() {
    const int BS = 1 << 22;
    static char buf[BS],*st=buf+BS,*ed=buf+BS;
    if( st == ed ) ed = buf + fread(st=buf,1,BS,stdin);
    return st == ed ? -1 : *st++;
}
inline int getint() {
    int ret = 0 , ch;
    while( !isdigit(ch=nextchar()) );
    do ret=ret*10+ch-'0'; while( isdigit(ch=nextchar()) );
    return ret;
}
 
int main() {
    n = getint() , m = getint() , q = getint();
    for(int i=1;i<=m;i++) {
        es[i].x = getint() , es[i].y = getint() , es[i].w = getint() , es[i].id = i;
        if( es[i].x > es[i].y ) std::swap( es[i].x , es[i].y );
    }
    for(int i=1;i<=q;i++) {
        ope[i] = getint() , x[i] = getint() , y[i] = getint() , --ope[i];
        if( x[i] > y[i] ) std::swap( x[i] , y[i] );
    }
    init() , pre() , getans();
    for(int i=1;i<=q;i++) if( !ope[i] ) printf("%d\n",ans[i]);
    return 0;
}

 

 

Bzoj5020:

传送门: http://www.lydsy.com/JudgeOnline/problem.php?id=5020

准确地说着不算是数据结构题，而是一道数学题。

他给的那三个函数显然都不可加，所以我们需要把他泰勒展开近似成多项式函数，然后LCT乱搞。

关于泰勒展开公式?

我们维护到x^17就行了，这种纠结的题多了T少了WA真是没办法……

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e5+1e2,maxl=20,lim=17;
 
double fac[maxl],c[maxl][maxl];
 
struct LCT {
    struct Node {
        double dat[maxl];
         
        inline void in(const double &a,const double &b,const int &tpe) {
            static double pa[maxl],pb[maxl];
            if( tpe != 3 ) {
                *pa = *pb = 1;
                for(int i=1;i<=lim;i++) pa[i] = pa[i-1] * a , pb[i] = pb[i-1] * b;
            }
            memset(dat,0,sizeof(dat));
            if( tpe == 1 ) {
                for(int i=1,t=1;i<=lim;i+=2,t=-t)
                    for(int j=0;j<=i;j++)
                        dat[j] += pa[j] * pb[i-j] * c[i][j] * t / fac[i];
            } else if( tpe == 2 ) {
                for(int i=0;i<=lim;i++)
                    for(int j=0;j<=i;j++)
                        dat[j] += pa[j] * pb[i-j] * c[i][j] / fac[i];
            } else if( tpe == 3 ) {
                dat[1] = a , dat[0] = b;
            }
        }
        inline double calc(const double &x) {
            static double pows[maxl];
            *pows = 1;
            for(int i=1;i<=lim;i++) pows[i] = pows[i-1] * x;
            double ret = 0;
            for(int i=0;i<=lim;i++) ret += dat[i] * pows[i];
            return ret;
        }
         
        friend Node operator + (const Node &a,const Node &b) {
            Node ret; memset(ret.dat,0,sizeof(ret.dat));
            for(int i=0;i<=lim;i++) ret.dat[i] = a.dat[i] + b.dat[i];
            return ret;
        }
    }dat[maxn],sum[maxn];
    int ch[maxn][2],fa[maxn],rev[maxn];
    inline void apply(int pos) {
        if( !pos ) return;
        rev[pos] ^= 1 ,
        swap(ch[pos][0],ch[pos][1]);
    }
    inline void push(int pos) {
        if( !rev[pos] ) return;
        apply(ch[pos][0]) , apply(ch[pos][1]) ,
        rev[pos] = 0;
    }
    inline void update(int x) {
        sum[x] = dat[x];
        if( ch[x][0] ) sum[x] = sum[x] + sum[ch[x][0]];
        if( ch[x][1] ) sum[x] = sum[x] + sum[ch[x][1]]; 
    }
    inline bool isrt(int x) {
        return x != ch[fa[x]][0] && x != ch[fa[x]][1];
    }
    inline bool gid(int x) {
        return x == ch[fa[x]][1];
    }
    inline void rotate(int x) {
        push(fa[x]) , push(x);
        const int f = fa[x] , id = gid(x);
        fa[x] = fa[f];
        if( !isrt(f) ) ch[fa[f]][gid(f)] = x;
        ch[f][id] = ch[x][id^1];
        if( ch[x][id^1] ) fa[ch[x][id^1]] = f;
        ch[x][id^1] = f , fa[f] = x;
        update(f) , update(x);
    }
    inline void pushchain(int x) {
        if( !isrt(x) ) pushchain(fa[x]);
        push(x);
    }
    inline void upchain(int x) {
        while(1) {
            update(x);
            if( isrt(x) ) break;
            x = fa[x];
        }
    }
    inline void splay(int x) {
        pushchain(x);
        while( !isrt(x) ) {
            if( !isrt(fa[x]) ) rotate(fa[x]);
            rotate(x);
        }
    }
    inline void access(int x) {
        int y = 0;
        while( x ) {
            splay(x) , ch[x][1] = y , update(x);
            y = x , x = fa[x];
        }
    }
    inline void mkrt(int x) {
        access(x) , splay(x) , apply(x);
    }
    inline void link(int x,int y) {
        mkrt(x) , fa[x] = y;
    }
    inline void cut(int x,int y) {
        mkrt(x) , access(y) , splay(y);
        ch[y][0] = fa[x] = 0 , update(y);
    }
    inline int findfa(int x) {
        while( fa[x] ) x = fa[x];
        return x;
    }
    inline Node query(int x,int y) {
        mkrt(x) , access(y) , splay(y);
        return sum[y];
    }
}T;
inline void pre() {
    *fac = 1;
    for(int i=1;i<=lim;i++) fac[i] = fac[i-1] * i;
    c[0][0] = 1;
    for(int i=1;i<=lim;i++) {
        c[i][0] = 1;
        for(int j=1;j<=i;j++) c[i][j] = c[i-1][j-1] + c[i-1][j];
    }
}
 
int main() {
    static int n,m;
    static char o[10];
    static double a,b;
    pre();
    scanf("%d%d%*s",&n,&m);
    for(int i=1,t;i<=n;i++) {
        scanf("%d%lf%lf",&t,&a,&b);
        T.dat[i].in(a,b,t);
    }
    for(int i=1,t,x,y;i<=m;i++) {
        scanf("%s",o);
        if( *o == 'a' ) {
            scanf("%d%d",&x,&y) , ++x , ++y;
            T.link(x,y);
        } else if( *o == 't' ) {
            scanf("%d%d%lf",&x,&y,&a) , ++x , ++y;
            if( T.findfa(x) != T.findfa(y) ) puts("unreachable");
            else {
                LCT::Node ans = T.query(x,y);
                printf("%.8e\n",ans.calc(a));
            }
        } else if( *o == 'm' ) {
            scanf("%d%d%lf%lf",&x,&t,&a,&b) , ++x;
            T.splay(x);
            T.dat[x].in(a,b,t);
        } else if( *o == 'd' ) {
            scanf("%d%d",&x,&y) , ++x , ++y;
            T.cut(x,y);
        }
    }
    return 0;
}

 

 

最后说几句废话(好像这篇全都是废话?):

为什么我这种辣鸡颓佬还能当Bzoj年榜Rank1?