Codeforces 707D Persistent Bookcase（bitset+dfs）★

题意：有一个有n行m列的书架，初始为空，现有q次操作，要求输出每次操作完之后书架上共有几本书。

           操作分为4种：

           1.在第i行第j列放入一本书。如果在操作之前第i行第j列已经有书了，那么忽略此次操作。

           2.将第i行第j列的书拿走。如果在操作之前第i行第j列没有书，那么忽略此次操作。

           3.将第i行的所有书反转。就是对于第i行的所有列，如果这个位置有书，那么将它拿走，如果这个位置没有书，那么放一本书到这个位置。

           4.将现在的整个书架的状态返回到第k次操作完之后的样子。

           1<=n,m<=1e3,1<=q<=1e5

题解：将所有的操作建成为一棵树，然后在树上操作就简单了。

           首先根节点一定是第0次操作，也就是初始值为空，对于之后的第i个操作，如果这个操作不是操作4，那么它的父亲节点是第i-1个操作，如果这个操作是操作4并且是回到第k次操作完之后的样子，那么这个节点的父亲是第k次操作。

           建完树之后进行一次树的遍历。回溯的时候要把原有的操作删除。

           需要注意的是原有的操作可能并不存在，比如原本第i行第j列已经有书了，这次操作又要求在这个位置添加一本书，那么就不会进行操作，同样回溯的时候也不能将这本书拿走。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <queue>
#include <map>
#include <bitset>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF  0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-3
#define maxn 100100
#define MOD 1000000007
struct Edge
{
    int to,next;
} edge[maxn];
int n,m,q;
bitset<1010> mp[1010];
int tot,head[maxn];
void add_edge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
int a[maxn],b[maxn],c[maxn],ans[maxn];

void dfs(int u,int pre)
{
    int flag = 0;
    //printf("%d %d %d\n",u,pre,ans[pre]);
    if(a[u])
    {
        ans[u] = ans[pre];
        if(a[u] == 1 && !mp[b[u]][c[u]])
        {
            flag = 1;
            mp[b[u]][c[u]] = 1;
            ans[u]++;
        }
        else if(a[u] == 2 && mp[b[u]][c[u]])
        {
            flag = 1;
            mp[b[u]][c[u]] = 0;
            ans[u]--;
        }
        else if(a[u] == 3)
        {
            //printf("%d %d %d %d\n",u,pre,m,mp[b[u]].count());
            int num1 = mp[b[u]].count();
            for(int i = 1; i <= m; i++)
                mp[b[u]].flip(i);
            int num2 = mp[b[u]].count();
            ans[u] += num2 - num1;
        }
    }
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        dfs(v,u);
    }
    if(a[u])
    {
        if(a[u] == 1 && flag)
            mp[b[u]][c[u]] = 0;
        else if(a[u] == 2 && flag)
            mp[b[u]][c[u]] = 1;
        else if(a[u] == 3)
            for(int i = 1; i <= m; i++)
                mp[b[u]].flip(i);
    }
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&q) != EOF)
    {
        tot = 0;
        memset(head,-1,sizeof(head));
        for(int i = 0; i < 1010; i++)
            mp[i].reset();
        a[0] = 0;
        ans[0] = 0;
        for(int i = 1; i <= q; i++)
        {
            scanf("%d",&a[i]);
            if(a[i] < 3)
            {
                scanf("%d%d",&b[i],&c[i]);
                add_edge(i-1,i);
            }
            else
            {
                scanf("%d",&b[i]);
                if(a[i] == 3)
                    add_edge(i-1,i);
                if(a[i] == 4)
                    add_edge(b[i],i);
            }
        }
        dfs(0,-1);
        for(int i = 1; i <= q; i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}