bzoj 3526: [Poi2014]Card 线段树

题意

有n张卡片在桌上一字排开，每张卡片上有两个数，第i张卡片上，正面的数为a[i]，反面的数为b[i]。现在，有m个熊孩子来破坏你的卡片了！
第i个熊孩子会交换c[i]和d[i]两个位置上的卡片。
每个熊孩子捣乱后，你都需要判断，通过任意翻转卡片（把正面变为反面或把反面变成正面，但不能改变卡片的位置），能否让卡片正面上的数从左到右单调不降。
n≤200000，m≤1000000，0≤a[i],b[i]≤10000000,1≤c[i],d[i]≤n.

分析

一开始想到线段树每个端点维护一个大小为4的布尔数组表示左端点个右端点取某个值时是否存在可行方案，然后合并的时候要乘上一个16倍的大常数，交一下果然T了。
但看到网上有人跟我用一样的方法过了，突然想起下午看到ImmortalCO在知乎上发了一篇文章，说写ds时直接开数组会比开struct快上一些，然后就改成了直接开数组，成功在bzoj上卡时通过。
然后在网上看到一个做法，就是说对每个节点开一个大小为2的int数组表示左端点取某个值时最小的右端点是多少，若不存在合法方案则为inf。这样的话常数可以除掉4，于是成功跑进第三榜。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define ls d<<1
#define rs d<<1|1

const int N=200005;
const int inf=1000000000;

int n,m,a[N][2],w[N*4][2];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void updata(int d,int l,int r)
{
    int mid=(l+r)/2;
    w[d][0]=w[d][1]=inf;
    if (w[ls][0]<=a[mid+1][0]) w[d][0]=std::min(w[d][0],w[rs][0]);
    if (w[ls][0]<=a[mid+1][1]) w[d][0]=std::min(w[d][0],w[rs][1]);
    if (w[ls][1]<=a[mid+1][0]) w[d][1]=std::min(w[d][1],w[rs][0]);
    if (w[ls][1]<=a[mid+1][1]) w[d][1]=std::min(w[d][1],w[rs][1]);
}

void build(int d,int l,int r)
{
    if (l==r) {w[d][0]=a[l][0];w[d][1]=a[l][1];return;}
    int mid=(l+r)/2;
    build(ls,l,mid);build(rs,mid+1,r);
    updata(d,l,r);
}

void modify(int d,int l,int r,int x)
{
    if (l==r) {w[d][0]=a[x][0];w[d][1]=a[x][1];return;}
    int mid=(l+r)/2;
    if (x<=mid) modify(ls,l,mid,x);
    else modify(rs,mid+1,r,x);
    updata(d,l,r);
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++) a[i][0]=read(),a[i][1]=read();
    build(1,1,n);
    m=read();
    while (m--)
    {
        int x=read(),y=read();
        std::swap(a[x][0],a[y][0]);
        std::swap(a[x][1],a[y][1]);
        modify(1,1,n,x);
        modify(1,1,n,y);
        if (w[1][0]<inf||w[1][1]<inf) puts("TAK");
        else puts("NIE");
    }
    return 0;
}