【牛客-白兔的字符串】滚动哈希

最新推荐文章于 2026-04-03 11:38:23 发布

原创最新推荐文章于 2026-04-03 11:38:23 发布 · 419 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

字符串处理专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种解决字符串循环同构问题的算法实现。通过计算目标字符串T的所有循环同构哈希值，并利用滚动哈希来高效地查找多个源字符串Si中与T循环同构的子串数量。

链接：https://ac.nowcoder.com/acm/problem/15253
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述

白兔有一个字符串T。白云有若干个字符串S1,S2…Sn。

白兔想知道，对于白云的每一个字符串，它有多少个子串是和T循环同构的。

提示：对于一个字符串a，每次把a的第一个字符移动到最后一个，如果操作若干次后能够得到字符串b，则a和b循环同构。

所有字符都是小写英文字母

输入描述:

第一行一个字符串T（|T|<=10^6）
第二行一个正整数n (n<=1000)
接下来n行为S1~Sn (|S1|+|S2|+…+|Sn|<=10^7)，max(|S1|,|S2|,|S3|,|S4|,..|Sn|)<=10^6

输出描述:

输出n行表示每个串的答案

示例1

输入

abab
2
abababab
ababcbaba

输出

5
2

思路

我们要求s1,s2,s3……sn 中字串和串 T 循环同构，我的做法是对于T串求出所有可以循环同构情况的哈希值，使用Map 标记。然后对于串 si 我用滚动哈希去求(长度和T相同)子串的哈希值，和Map 比对。

对于这个题可能哈希冲突的很多，对于基数和模的选择要求很高。

import java.util.*;


public class Main {
    private static long[] p = new long[1000100];/**/
    private static long mod=2147483587;/*取模 散列表的长度*/
    private static long B=25165843;/*基数*/
    public static void main(String[] args) {
        p[0]=1;
        for (int i=1;i<=1e6+2;i++){
            p[i]=(p[i-1]*B)%mod;
        }
        Scanner scanner = new Scanner(System.in);
        String T = scanner.nextLine();
        HashMap<Long,Boolean> map = new HashMap<>();
        long hashT=0;
        /*求出T的所有情况*/
        for (int i = 0; i <T.length() ; i++) {
            hashT = ((hashT*B)%mod+Integer.valueOf(T.charAt(i)))%mod;
        }
       
        map.put(hashT,true);
        for (int i=0;i<T.length()-1;i++){
            /*注意·这里防止hashT为负数 要加mod */
            hashT = (hashT-(Integer.valueOf(T.charAt(i))*p[T.length()-1])%mod+mod)%mod;
            hashT=((hashT*B)%mod+Integer.valueOf(T.charAt(i)))%mod;
            map.put(hashT,true);
        }
        int n = scanner.nextInt();
        scanner.nextLine();
        while (0!=n--){
            String s = scanner.nextLine();
            int num=0;
            if(s.length()<T.length()){
                System.out.println(0);
                continue;
            }
            long hashS=0;
            for (int i = 0; i < T.length(); i++) {
                hashS=(hashS*B)%mod+Integer.valueOf(s.charAt(i));
            }
            if (map.containsKey(hashS)==true) {
                num++;
            }
            /*滚动哈希*/
            for (int i = 1; i+T.length()-1 <s.length() ; i++) {
                /*注意·这里防止hashT为负数 要加mod */
                hashS=(hashS-(Integer.valueOf(s.charAt(i-1))*p[T.length()-1])%mod+mod)%mod;
                hashS=(hashS*B)%mod+Integer.valueOf(s.charAt(i+T.length()-1))%mod;
                if(map.containsKey(hashS)==true){
                    num++;
                }
            }
            System.out.println(num);
        }
    }
}