【Codeforces Round #368 (Div. 2) D. Persistent Bookcase】线段树

链接：

https://codeforces.com/contest/707/problem/D

题意

有n个书架，每个书架上有m个位置可以放书，现在要维护4种操作。
1,x,y:如果第x个书架的第y个位置没有书，在第x个书架的第y个位置放置一本书
2,x,y:如果第x个书架的第y个位置有书，把第x个书架的第y个位置的书拿走
3,x: 将第x书架所有有书的位置的书拿走，将x书架所有没有书的位置放上书
4,x:返回第x次操作后状态
要求每步操作之后返回当前书的个数。

做法

首先每一步操作都是从之前的某步操作转过来的，所以整个操作顺序是一颗有向树，我们只要按顺序dfs，问题就变成单点更新，区间求和，但是要注意的是，回溯撤销操作的时候要看操作的时候是否对状态进行改变，比如本来有书又放一本书，没有对状态进行改变，回溯操作的时候就不能取走这本书。

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 1e6+5;
struct data
{
    int op;
    int x,y;
}Q[maxn];
int n,m,q;
struct T
{
    int l,r,mid;
    int sum,add;
}tree[maxn<<2];
vector<int>G[maxn];
void down(int rt)
{
    if(tree[rt].add)
    {
        tree[rt<<1].sum=(tree[rt<<1].r-tree[rt<<1].l+1)-tree[rt<<1].sum;
        tree[rt<<1|1].sum=(tree[rt<<1|1].r-tree[rt<<1|1].l+1)-tree[rt<<1|1].sum;
        tree[rt<<1].add=1-tree[rt<<1].add;
        tree[rt<<1|1].add=1-tree[rt<<1|1].add;
        tree[rt].add=0;
    }
}
void up(int rt)
{
    tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
}
void build(int rt,int l,int r)
{
    tree[rt].l=l;
    tree[rt].r=r;
    tree[rt].sum=0;
    tree[rt].add=0;
    if(l==r) return;
    int mid=tree[rt].mid=l+r>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
}
bool update(int rt,int pos,int val)
{
    if(tree[rt].l==tree[rt].r)
    {
        int tt=tree[rt].sum;
        tree[rt].sum=val;
        return (tt!=val);
    }
    down(rt);
    bool ans;
    if(tree[rt].mid>=pos) ans=update(rt<<1,pos,val);
    else ans=update(rt<<1|1,pos,val);
    up(rt);
    return ans;
}
void update_(int rt,int l,int r)
{
    if(tree[rt].l>r||tree[rt].r<l) return ;
    if(tree[rt].l>=l&&tree[rt].r<=r)
    {
        tree[rt].add=1-tree[rt].add;
        tree[rt].sum=tree[rt].r-tree[rt].l+1-tree[rt].sum;
        return ;
    }
    down(rt);
    if(tree[rt].mid>=l) update_(rt<<1,l,r);
    if(tree[rt].mid<r) update_(rt<<1|1,l,r);
    up(rt);
}
int ans[maxn];
void dfs(int rt)
{
    int flag=0;
    if(rt!=0)
    {
        if(Q[rt].op==1)
        {
            if(update(1,(Q[rt].x-1)*m+Q[rt].y,1)) flag=1;
        }
        else if(Q[rt].op==2)
        {
            if(update(1,(Q[rt].x-1)*m+Q[rt].y,0)) flag=1;
        }
        else if(Q[rt].op==3) update_(1,(Q[rt].x-1)*m+1,Q[rt].x*m);
    }
    ans[rt]=tree[1].sum;
    for(int i=0;i<G[rt].size();i++)
    {
        dfs(G[rt][i]);
    }
    if(rt!=0)
    {
        if(Q[rt].op==1&&flag==1) update(1,(Q[rt].x-1)*m+Q[rt].y,0);
        else if(Q[rt].op==2&&flag==1) update(1,(Q[rt].x-1)*m+Q[rt].y,1);
        else if(Q[rt].op==3) update_(1,(Q[rt].x-1)*m+1,Q[rt].x*m);
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=q;i++)
    {
        scanf("%d",&Q[i].op);
        if(Q[i].op==1||Q[i].op==2)
        {
            G[i-1].push_back(i);
            scanf("%d%d",&Q[i].x,&Q[i].y);
        }
        else if(Q[i].op==3)
        {
            G[i-1].push_back(i);
            scanf("%d",&Q[i].x);
        }
        else
        {
            scanf("%d",&Q[i].x);
            G[Q[i].x].push_back(i);
        }
    }
    build(1,1,n*m);
    dfs(0);
    for(int i=1;i<=q;i++) printf("%d\n",ans[i]);
    return 0;
}