【10.6校内测试】【小模拟】【hash+线段树维护覆盖序列】

一开始看到题就果断跳到T2了！！没想到T2才是个大坑，浪费了两个小时QAQ！！

就是一道小模拟，它怎么说就怎么走就好了！

为什么要用这么多感叹号！！因为统计答案要边走边统计！！如果每个数据都扫一遍2000*2000就炸了！！！

我爆哭QAQ再也不用stl的max叻！！（然而一定会被打脸）我的100分QAQAQAQ

#include<bits/stdc++.h>
using namespace std;

int k, n;
int vis[][];
char s[];

int main() {
    freopen("block.in", "r", stdin);
    freopen("block.out", "w", stdout);
    int T;
    scanf("%d", &T);
    while(T --) {
        scanf("%d", &k);
        scanf("%s", s);
        int now = ;
        memset(vis, , sizeof(vis));
        vis[][] ++;
        int lx = , ly = , rx = , ry = ;
        int ans = ;
        for(int i = ; i < strlen(s); i ++) {
            char opt = s[i];
            if(opt == 'N') {
                if(now) {
                    if(rx == lx + ) {
                        vis[lx][ly+k] ++;
                        if(vis[lx][ly+k] > ans)    ans = vis[lx][ly+k];
                        ly = ry, ry ++;
                        now = ;
                    } else {
                        for(int p = lx; p < rx; p ++) {
                            vis[p][ry] ++;
                            if(vis[p][ry] > ans)    ans = vis[p][ry];
                        }
                        ly ++, ry ++;
                    }
                } else {
                    for(int p = ly + ; p <= ly + k; p ++) {
                        vis[lx][p] ++;
                        if(vis[lx][p] > ans)    ans = vis[lx][p];
                    }
                    ly ++; ry += k;
                    now = ;
                }
            } else if(opt == 'S') {
                 if(now) {
                     if(rx == lx + ) {
                         vis[lx][ly-] ++;
                         if(vis[lx][ly-] > ans)    ans = vis[lx][ly-];
                         ly --; ry = ly + ;
                         now = ;
                     } else {
                         for(int p = lx; p < rx; p ++) {
                             vis[p][ly-] ++;
                             if(vis[p][ly-] > ans)    ans = vis[p][ly-];
                         }
                         ly --; ry --;
                     }
                 } else {
                     for(int p = ly - ; p >= ly - k; p --) {
                         vis[lx][p] ++;
                         if(ans < vis[lx][p])    ans = vis[lx][p];
                     }
                     ry = ly; ly = ly - k;
                     now = ;
                 }
            } else if(opt == 'W') {
                if(now) {
                    if(rx == lx + ) {
                        for(int p = ly; p < ry; p ++) {
                            vis[lx-][p] ++;
                            if(vis[lx-][p] > ans)    ans = vis[lx-][p];
                        }
                        lx --; rx --;
                    } else {
                        vis[lx-][ly] ++;
                        if(vis[lx-][ly] > ans)    ans = vis[lx-][ly];
                        lx --; rx -= k;
                        now = ;
                    }
                } else {
                    for(int p = lx - k; p < lx; p ++) {
                        vis[p][ly] ++;
                        if(vis[p][ly] > ans)    ans = vis[p][ly];
                    }

                    lx -= k; rx --;
                    now = ;
                }
            } else {
                if(now) {
                    if(rx == lx + ) {
                        for(int p = ly; p < ry; p ++) {
                            vis[lx+][p] ++;
                            if(vis[lx+][p] > ans)    ans = vis[lx+][p];
                        }
                        lx ++; rx ++;
                    } else {
                        vis[lx+k][ly] ++;
                        if(vis[lx+k][ly] > ans)    ans = vis[lx+k][ly];
                        lx += k; rx ++;
                        now = ;
                    }
                } else {
                    for(int p = lx + ; p < rx + k; p ++) {
                        vis[p][ly] ++;
                        if(vis[p][ly] > ans)    ans = vis[p][ly];
                    }
                    lx ++; rx += k;
                    now = ;
                }
            }
        }
        if(rx == lx + ) {
            int sum = ry - ly;
            for(int i = ; i < sum; i ++)
                printf("%d ", lx - );
            printf("%d", lx - );
            printf("\n");
            for(int i = ly; i < ry-; i ++)
                printf("%d ", i - );
            printf("%d", ry - );
            printf("\n");
        } else {
            int sum = rx - lx;
            for(int i = lx; i < rx-; i ++)
                printf("%d ", i - );
            printf("%d", rx - );
            printf("\n");
            for(int i = ; i < sum; i ++)
                printf("%d ", ly - );
            printf("%d", ly - );
            printf("\n");
        }
        printf("%d\n", ans);
    }
    return ;
}

这道题暴力分拿的太爽了，15分钟敲出来70分成了救命稻草QAQAQ

区间修改考虑线段树。

因为目标的覆盖序列只有一个，就是1~k。其他的序列都不合法，怎么才能在最后快速判断是否合法呢？

想到$hash$，每次覆盖相当于在$hash$序列中加一个数，在线段树上转化成了$*A+B$（$A$就是$base$，$B$就是新增的数），于是就可以维护了。

最后查询$Dfs$将每个叶子节点的$hash$值存下来即可。

#include<bits/stdc++.h>
#define base 233
using namespace std;

int n, k, t;
unsigned int tag1[], tag2[];
unsigned int TR[], has[];

void build(int nd, int l, int r) {
    tag1[nd] = ; tag2[nd] = ;
    if(l == r) return ;
    int mid = (l + r) >> ;
    build(nd << , l, mid);
    build(nd <<  | , mid + , r);
}

void push_down(int nd, int l, int r) {
    if(tag1[nd] !=  || tag2[nd] != ) {
        TR[nd<<] = TR[nd<<] * tag1[nd] + tag2[nd];
        TR[nd<<|] = TR[nd<<|] * tag1[nd] + tag2[nd];
        tag1[nd<<] = tag1[nd] * tag1[nd<<];
        tag1[nd<<|] = tag1[nd] * tag1[nd<<|];
        tag2[nd<<] = tag1[nd] * tag2[nd<<] + tag2[nd];
        tag2[nd<<|] = tag1[nd] * tag2[nd<<|] + tag2[nd];
        tag1[nd] = ; tag2[nd] = ;
    }
}

void modify(int nd, int l, int r, int L, int R, int d) {
    if(l >= L && r <= R) {
        TR[nd] = TR[nd] * base + d;
        tag2[nd] = tag2[nd] * base + d;
        tag1[nd] = tag1[nd] * base;
        return ;
    }
    push_down(nd, l, r);
    int mid = (l + r) >> ;
    if(L <= mid)    modify(nd << , l, mid, L, R, d);
    if(R > mid)        modify(nd <<  | , mid + , r, L, R, d);

}

void query(int nd, int l, int r) {
    if(l == r) {
        has[l] = TR[nd];
        return ;
    }
    push_down(nd, l, r);
    int mid = (l + r) >> ;
    query(nd << , l, mid);
    query(nd <<  | , mid + , r);
}

int main() {
    freopen("deco.in", "r", stdin);
    freopen("deco.out", "w", stdout);
    scanf("%d%d%d", &n, &k, &t);
    build(, , n);
    for(int i = ; i <= t; i ++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        modify(, , n, a, b, c);
    }
    query(, , n);
    int h = ;
    for(int i = ; i <= k; i ++)
        h = h * base + i;
    int ans = ;
    for(int i = ; i <= n; i ++)
        if(has[i] == h)    ans ++;
    printf("%d", ans);
    return ;
}