HDU 3973 AC's String 字符串哈希

HDU 3973

通过哈希函数将一个字符串转化为一个整数，通过特定的方式可以使得这个哈希值几乎没有冲突（这就是关键之处，几乎没有视为没有= =！， 其实也可以考虑实现哈希冲突时的处理，只是这道题没必要而已），然后使用线段树维护修改后的哈希值。

因为输入的字符串只有26个，考虑使用一个大于等于26的素数p作为进制，然后将原串转化为一个p进制的数mod 2^63(也相当于自然溢出)，然后这个数存入map中，然后使用线段树维护长串区间的哈希值，hash[l, r]表示将区间[l, r]的字符串转化为p进制数（哈希过程）的结果，那么对于当前区间[l, r]的两个子区间[l, m]与[m + 1, r]:

hash[l, r] = hash[l, m] + hash[m + 1, r] * (p ^ (m - l + 1))

使用线段树动态维护，查询区间的hash值，使用map查找，那么问题就解决了。

 //#pragma comment(linker, "/STACK:1677721600")
 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define inf (-((LL)1<<40))
 #define lson k<<1, L, (L + R)>>1
 #define rson k<<1|1,  ((L + R)>>1) + 1, R
 #define mem0(a) memset(a,0,sizeof(a))
 #define mem1(a) memset(a,-1,sizeof(a))
 #define mem(a, b) memset(a, b, sizeof(a))
 #define FIN freopen("in.txt", "r", stdin)
 #define FOUT freopen("out.txt", "w", stdout)
 #define rep(i, a, b) for(int i = a; i <= b; i ++)
 #define dec(i, a, b) for(int i = a; i >= b; i --)

 template<class T> T MAX(T a, T b) { return a > b ? a : b; }
 template<class T> T MIN(T a, T b) { return a < b ? a : b; }
 template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
 template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

 //typedef __int64 LL;
 typedef long long LL;
 const int MAXN =  + ;
 const int MAXM = ;
 const double eps = 1e-;
 LL MOD = ;

 const LL P = ;

 int t, n, m, cas = , l, r;
 LL mi[MAXN];
 char str[], ch;
 map<LL, int>mp;

 void init() {
     mi[] = ;
     rep (i, , MAXN - ) {
         mi[i] = mi[i - ] * P;
     }
 }

 int toNum(char ch) {
     return ch - 'a' + ;
 }

 LL Hash() {
     LL ans = ;
     int len = strlen(str);
     dec (i, len - , ) {
         ans = ans * P + toNum(str[i]);
     }
     return ans;
 }

 struct SegTree {
     LL ma[MAXN << ];

     void update(int k, int L, int R, int p, int v) {
         if(L == R) { ma[k] = v; return ; }
         int mid = (L + R) >> ;
         if(mid >= p) update(lson, p, v);
         else update(rson, p, v);
         ma[k] = ma[k << ] + ma[k <<  | ] * mi[mid - L + ];
     }

     LL query(int k, int L, int R, int l, int r) {
         if(r < L || R < l) return ;
         if(l <= L && R <= r) return ma[k];
         LL le = query(lson, l, r), ri = query(rson, l, r);
         int mid = (L + R) >> ;
         return le + ri * mi[max(mid - max(L, l) + , )];
     }

 }st;

 int main()
 {
 //    FIN;
     init();
     cin >> t;
     while(t--) {
         mp.clear();
         mem0(st.ma);
         scanf("%d%*c", &n);
         rep (i, , n - ) {
             scanf("%s", str);
             mp[Hash()] = ;
         }
         scanf("%s", str);
         int len = strlen(str);
         rep (i, , len - ) {
             st.update(, , len, i + , toNum(str[i]));
         }
         printf("Case #%d:\n", ++cas);
         scanf("%d%*c", &m);
         while(m --) {
             scanf("%c", &ch);
             if(ch == 'Q') {
                 scanf("%d %d%*c", &l, &r);
                 printf("%s\n", mp[st.query(, , len, ++l, ++r)] ? "Yes" : "No");
             }
             else {
                 scanf("%d %c%*c", &l, &ch);
                 st.update(, , len, ++l, toNum(ch));
             }
         }
     }
     return ;
 }