BZOJ 3514 Codechef MARCH14 GERALD07加强版

从CC抠的题 xyz大神直接用分块秒 虽然会MLE+TLE

时限被改成40s了，我觉得30s足够了吧……

考虑从左至右加入每一条边，加入某条边成环的环那么这条边对答案就没有影响。那么只要环上标号最小的边没被加入就会对答案有影响。

所以问题变成了区间询问小于某个数的数有多少个，这个主席树就行了。

至于前面那一步，用动态树求出来就行了。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<algorithm>
 
using namespace std;
 
const int BUF_SIZE = 30;
char buf[BUF_SIZE], *buf_s = buf, *buf_t = buf + 1;
  
#define PTR_NEXT() 
    { 
        buf_s ++; 
        if (buf_s == buf_t) 
        { 
            buf_s = buf; 
            buf_t = buf + fread(buf, 1, BUF_SIZE, stdin); 
        } 
    }
   
#define readint(_n_) 
    { 
        while (*buf_s != '-' && !isdigit(*buf_s)) 
            PTR_NEXT(); 
        bool register _nega_ = false; 
        if (*buf_s == '-') 
        { 
            _nega_ = true; 
            PTR_NEXT(); 
        } 
        int register _x_ = 0; 
        while (isdigit(*buf_s)) 
        { 
            _x_ = _x_ * 10 + *buf_s - '0'; 
            PTR_NEXT(); 
        } 
        if (_nega_) 
            _x_ = -_x_; 
        (_n_) = (_x_); 
    }

const int maxn=200010;
const int maxp=maxn*20;
const int INF=0x3f3f3f3f;
 
int n,m,k,wmt,type,s[maxn],e[maxn],root[maxn];
 
struct tree_node
{
    int l,r;
    int sum;
    void init()
    {
        l=r=sum=0;
    }
}y[maxp];
 
int newnode()
{
    y[++wmt].init();
    return wmt;
}
 
int insert(int p,int l,int r,int v)
{
    int pp=newnode();
    if (l==r)
    {
        y[pp].sum=y[p].sum+1;
        return pp;
    }
    int m=(l+r)>>1;
    if (v<=m)
    {
        y[pp].l=insert(y[p].l,l,m,v);
        y[pp].r=y[p].r;
    }
    else
    {
        y[pp].l=y[p].l;
        y[pp].r=insert(y[p].r,m+1,r,v);
    }
    y[pp].sum=y[y[pp].l].sum+y[y[pp].r].sum;
    return pp;
}
 
int query(int p1,int p2,int l,int r,int nowl,int nowr)
{
    if (nowl<=l && r<=nowr) return y[p1].sum-y[p2].sum;
    int m=(l+r)>>1;
    if (nowl<=m)
    {
        if (m<nowr) return query(y[p1].l,y[p2].l,l,m,nowl,nowr)+query(y[p1].r,y[p2].r,m+1,r,nowl,nowr);
        else return query(y[p1].l,y[p2].l,l,m,nowl,nowr);
    }
    else return query(y[p1].r,y[p2].r,m+1,r,nowl,nowr);
}
 
struct node
{
    int l,r,f,v,minv;
    bool rev,rt;
    void init()
    {
        l=r=f=0;
        rev=false;
        rt=true;
        minv=INF;
    }
}z[maxn<<1];
 
void update(int x)
{
    z[x].minv=z[x].v;
    if (z[x].l) z[x].minv=min(z[x].minv,z[z[x].l].minv);
    if (z[x].r) z[x].minv=min(z[x].minv,z[z[x].r].minv);
}
 
void rot_l(int x)
{
    int y=z[x].r;
    z[x].r=z[y].l;
    z[y].l=x;
    if (z[x].rt) z[x].rt^=1,z[y].rt^=1;
    else
    {
        if (z[z[x].f].l==x) z[z[x].f].l=y;
        else z[z[x].f].r=y;
    }
    z[y].f=z[x].f;
    z[x].f=y;
    z[z[x].r].f=x;
}
 
void rot_r(int x)
{
    int y=z[x].l;
    z[x].l=z[y].r;
    z[y].r=x;
    if (z[x].rt) z[x].rt^=1,z[y].rt^=1;
    else
    {
        if (z[z[x].f].l==x) z[z[x].f].l=y;
        else z[z[x].f].r=y;
    }
    z[y].f=z[x].f;
    z[x].f=y;
    z[z[x].l].f=x;
}
 
void push(int x)
{
    if (z[x].rev)
    {
        z[z[x].l].rev^=1;
        swap(z[z[x].l].l,z[z[x].l].r);
        z[z[x].r].rev^=1;
        swap(z[z[x].r].l,z[z[x].r].r);
        z[x].rev^=1;
    }
}
 
void splay(int x)
{
    while (!z[x].rt)
    {
        int f=z[x].f;
        int ff=z[f].f;
        push(ff);
        push(f);
        push(x);
        if (z[f].rt)
        {
            if (z[f].l==x) rot_r(f);
            else rot_l(f);
        }
        else
        {
            if (z[ff].l==f && z[f].l==x)
            {
                rot_r(ff);
                rot_r(f);
            }
            if (z[ff].l==f && z[f].r==x)
            {
                rot_l(f);
                rot_r(ff);
            }
            if (z[ff].r==f && z[f].l==x)
            {
                rot_r(f);
                rot_l(ff);
            }
            if (z[ff].r==f && z[f].r==x)
            {
                rot_l(ff);
                rot_l(f);
            }
        }
        update(ff);
        update(f);
    }
    update(x);
    push(x);
}
 
void access(int x)
{
    int p1=x,p2=0;
    do
    {
        splay(p1);
        z[z[p1].r].rt=true;
        z[p2].rt=false;
        z[p1].r=p2;
        z[p2].f=p1;
        update(p1);
        p2=p1;
        p1=z[p1].f;
    }while(p1);
}
 
void join(int p1,int p2)
{
    access(p1);
    splay(p1);
    z[p1].rev^=1;
    swap(z[p1].l,z[p1].r);
    z[p1].f=p2;
}
 
void cut(int p1,int p2)
{
    access(p1);
    splay(p2);
    if (z[p2].f==p1) z[p2].f=0;
    else
    {
        access(p2);
        splay(p1);
        z[p1].f=0;
    }
}
 
bool connect(int p1,int p2)
{
    access(p2);
    for (;p1;p1=z[p1].f)
    {
        splay(p1);
        if (!z[p1].f) break;
    }
    for (;z[p1].r;p1=z[p1].r);
    return p1==p2;
}
 
int query(int x,int y)
{
    access(y);
    int ans=INF;
    for (y=0;x;x=z[x].f)
    {
        splay(x);
        if (!z[x].f)
        {
            ans=z[x].v;
            if (y) ans=min(ans,z[y].minv);
            if (z[x].r) ans=min(ans,z[z[x].r].minv);
            break;
        }
        z[z[x].r].rt=true;
        z[y].rt=false;
        z[x].r=y;
        y=x;
        update(y);
    }
    return ans;
}
 
 
int main()
{

    readint(n);
    readint(m);
    readint(k);
    readint(type);
    for (int a=1;a<=m;a++)
    {
        readint(s[a]);
        readint(e[a]);
    }
    for (int a=1;a<=n+m;a++)
    {
        z[a].init();
        if (a<=n) z[a].v=z[a].minv=INF;
        else z[a].v=z[a].minv=a-n;
    }
    wmt=0;
    for (int a=1;a<=m;a++)
    {
        int p1=s[a],p2=e[a];
        if (p1==p2)
        {
            root[a]=insert(root[a-1],0,m,a);
            continue;
        }
        if (connect(p1,p2))
        {
            int value=query(p1,p2);
            cut(value+n,s[value]);
            cut(value+n,e[value]);
            root[a]=insert(root[a-1],0,m,value);
            join(a+n,p1);
            join(a+n,p2);
        }
        else 
        {
            root[a]=insert(root[a-1],0,m,0);
            join(a+n,p1);
            join(a+n,p2);
        }
    }
    int l,r;
    for (int a=1,lastans=0;a<=k;a++)
    {
        readint(l);
        readint(r);
        if (type==1) l^=lastans,r^=lastans;
        printf("%d
",(lastans=n-query(root[r],root[l-1],0,m,0,l-1)));
    }

    return 0;
}