字符串hash+线段树 Codeforces580E Kefa and Watch

传送门：点击打开链接

题意：给你一个原串，只有0和9组成。现在有两种操作

操作1，区间修改，把[L,R]的数字都改成d

操作2，询问区间[L,R]中是否满足si = si + x for all i from 1 to |s| - x.

思路：虽然本身会字符串hash，但是没想到还能这样玩。。hash的思路和普通的是一样的，每一位中间乘以某个数字。。如果担心最后的答案，可以对两个大质数取模，看两个数字是否都相等，如果都相等，那么两个字符串就可以认为是相等的。

S用来维护一个区间内的子串hash值，通过把左树和右树的答案合并可以得到。那么查询字符串是否相等有什么用呢。。

我们可以去想象，如果令len=R-L+1,也就是区间长度

如果len<d,那么肯定NO

否则如果len==d,那么肯定是YES

否则，设k=len/d

  如果k==1,说明如果[L,R-d]等于[L+d,R]时，就可以认为YES了

  如果k>1,那么如果len恰好是d的倍数，那么只要总区间的(k-1)*d长度和总区间的右边的(k-1)*d长度的字符串完全相等即可。

                 如果len%d!=0,那么在满足上面倍数部分的要相等，还要考虑最后那多出来的一小段是否也相等即可

wa点：看上去好像必须要求是要求整个序列存在循环节，其实这里面有的判断并不是完整的，比如区间[1,3]如果是1,2,1,d=2那么可以发现k=1,实际上中间那个2是根本没考虑的，只需要区间第一个等于区间中第三个即可满足要求了。最难相通的部分就在于查询的时候len和d之间的讨论

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<cstdio>
#include<cctype>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define fuck printf("fuck")
#define FIN freopen("input.txt","r",stdin)
#define FOUT freopen("output.txt","w+",stdout)
using namespace std;
typedef long long LL;

const int MX = 1e5 + 5;
const LL X = 233333;
const LL mod = 1e9 + 7;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define root 1,n,1

char A[MX];
LL F[MX], Fs[MX];
LL S[MX << 2], col[MX << 2];

void init() {
    F[0] = 1; Fs[0] = 0;
    for(int i = 1; i < MX; i++) {
        F[i] = F[i - 1] * X % mod;
        Fs[i] = (Fs[i - 1] + F[i]) % mod;
    }
}

void push_up(int rt, int len) {
    len = len - (len >> 1);
    S[rt] = (S[rt << 1] + S[rt << 1 | 1] * F[len]) % mod;
}

void push_down(int rt, int len) {
    if(col[rt]) {
        col[rt << 1] = col[rt << 1 | 1] = col[rt];
        S[rt << 1] = Fs[len - (len >> 1)] * col[rt] % mod;
        S[rt << 1 | 1] = Fs[len >> 1] * col[rt] % mod;
        col[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    col[rt] = 0;
    if(l == r) {
        S[rt] = F[1] * A[l] % mod;
        return;
    }

    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    push_up(rt, r - l + 1);
}

void update(int L, int R, int d, int l, int r, int rt) {
    if(L <= l && r <= R) {
        S[rt] = Fs[r - l + 1] * d % mod;
        col[rt] = d;
        return;
    }

    int m = (l + r) >> 1;
    push_down(rt, r - l + 1);
    if(L <= m) update(L, R, d, lson);
    if(R > m) update(L, R, d, rson);
    push_up(rt, r - l + 1);
}

LL query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) {
        return S[rt];
    }

    int m = (l + r) >> 1;
    int len = m - max(l, L) + 1;
    push_down(rt, r - l + 1);

    LL ls = -1, rs = -1;
    if(L <= m) ls = query(L, R, lson);
    if(R > m) rs = query(L, R, rson);

    if(~ls && ~rs) return (ls + rs * F[len]) % mod;
    else if(ls == -1) return rs;
    return ls;
}

bool solve(int n, int l, int r, int d) {
    int len = r - l + 1;
    if(len == d) return true;
    if(len < d) return false;

    LL t1, t2;
    int k = len / d;
    if(k == 1) {
        t1 = query(l, r - d, root);
        t2 = query(l + d, r, root);
        return t1 == t2;
    } else {
        if(len % d) {
            t1 = query(l, l + len % d - 1, root);
            t2 = query(r - len % d + 1, r, root);
            if(t1 != t2) return false;
        }

        t1 = query(l, l + (k - 1) * d - 1, root);
        t2 = query(r - (k - 1) * d + 1, r, root);
        return t1 == t2;
    }
}

int main() {
    init();
    int n, q, qt; //FIN;
    while(~scanf("%d%d%d", &n, &q, &qt)) {
        q += qt;
        scanf("%s", A + 1);
        for(int i = 1; i <= n; i++) {
            A[i] = A[i] - '0' + 1;
        }

        build(root);
        for(int i = 1; i <= q; i++) {
            int op, l, r, d;
            scanf("%d%d%d%d", &op, &l, &r, &d);
            if(op == 1) update(l, r, d + 1, root);
            else printf("%s\n", solve(n, l, r, d) ? "YES" : "NO");
        }
    }
    return 0;
}