codeforces 707D Persistent Bookcase 离线+深搜

/*
    题意：给定一个n行m列的书架，每次有4种操作，1 x y 是如果(x, y)位置没有书，就在这个位置放一本书，
         2 x y是如果(x , y)有书，就把这个位置的书拿走， 3 y 是把第y行空的位置放上书，有书的位置把书
         拿走，4 k是回到第k次操作之后的状态，每个操作过后将书架上的书的总数输出

    方法：采用离线处理，首先建图，对于第i次操作，如果不是类型4的话，就从i-1向i连一条边；如果是类型
         4，且还原到的操作是第k次后，那么就从k向i连一条边。用一个二维数组模拟书架，然后dfs搜索上述的
         的图，每次搜索到第i次的时候离线存下第i次操作的后结果ans[i]，然后从1到m依次输出ans[i]即可
*/
#pragma warning(disable:4786)
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#include<string>
#include<sstream>
#define LL long long
#define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;++i)
#define mem(a,x) memset(a,x,sizeof(a))
#define lson l,m,x<<1
#define rson m+1,r,x<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps=1e-6;
const int maxn = 1e5 + 3;
const int maxs = 1e3 + 5 ;
vector<int>G[maxn];
int bookcase[maxs][maxs] , type[maxn] ; //type[i]:第i次操作的类型
int n , m , Q ;
struct node
{
    int ax , ay , rx , ry ,inx;
}q[maxn]; //第i次操作：（ax，ay）位置加一个，（rx，ry）减一个，第inx行反转
int ans[maxn] ;
void dfs(int cur , int sum)
{
    ans[cur] = sum ;
    int len = G[cur].size();
    for(int i = 0 ; i<len ; i++){
        int nt = G[cur][i] , nsum ;
        if(type[nt] == 1){
            if(bookcase[ q[nt].ax ][ q[nt].ay ] != 0){
                dfs( nt , sum ) ;
                continue ;
            }
            nsum = sum + 1 ;
            bookcase[ q[nt].ax ][ q[nt].ay ]++;
            dfs(nt , nsum)  ;
            bookcase[ q[nt].ax ][ q[nt].ay ] -- ;              //对于每种类型，都要记得进行回溯，所以把书架变回到操作之前的状态
        }
        else if(type[nt] == 2){
            if(bookcase[ q[nt].rx ][ q[nt].ry ] == 0){
                dfs(nt , sum) ;
                continue ;
            }
            nsum = sum - 1 ;
            bookcase[ q[nt].rx ][ q[nt].ry ]--;
            dfs(nt , nsum)  ;
            bookcase[ q[nt].rx ][ q[nt].ry ] ++ ;
        }
        else if(type[nt] == 3){
            int before = 0 , after = 0 ;
            for(int i = 1 ; i<= m ; i++){
                if(bookcase[ q[nt].inx ][i] == 0){
                    bookcase[ q[nt].inx ][i] = 1;
                    ++after ;
                }
                else{
                    bookcase[ q[nt].inx ][i] = 0 ;
                    ++before ;
                }
            }
            nsum = sum + (after - before) ;
            dfs(nt , nsum) ;
            for(int i = 1 ; i<= m ; i++){
                if(bookcase[ q[nt].inx ][i] == 0){
                    bookcase[ q[nt].inx ][i] = 1;
                }
                else{
                    bookcase[ q[nt].inx ][i] = 0 ;
                }
            }
        }
        else{
            dfs( nt , sum ) ;
        }
    }
}
int main()
{
    int  Q;
    scanf("%d%d%d",&n,&m,&Q);
    mem(ans , 0) ;
    mem(bookcase , 0) ;
    for(int i = 1 ; i<=Q ; i++){
        scanf("%d",&type[i]) ;
        if(type[i] == 1){
            scanf("%d%d",&q[i].ax , &q[i].ay) ;
        }
        else if(type[i] == 2){
            scanf("%d%d",&q[i].rx , &q[i].ry) ;
        }
        else if(type[i] == 3){
            scanf("%d",&q[i].inx) ;
        }
        else{
            int k ;
            scanf("%d",&k);
            G[k].push_back(i) ;
        }
        if(type[i] != 4)
            G[i - 1].push_back(i) ;
    }
    dfs( 0 ,0 ) ;
    for(int i = 1 ; i<= Q ; i++){
        printf("%d\n",ans[i]) ;
    }
    return 0;
}