洛谷P5546公共串的SAM解法代码（含二分哈希）

已于 2024-08-31 13:14:36 修改
阅读量341 收藏 8
点赞数 5
文章标签： c++
于 2024-08-31 00:03:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73633818/article/details/141729941
版权

写作原因：

我看网上大部分都是二分哈希的做法但却没有后缀自动机SAM的解法代码，因此提供两个SAM的解法，两个解法我都不详细介绍，会提供原文章地址和我个人的代码。个人认为第二种解法在时间和空间复杂度上都更优，也更好理解（前提你熟悉两个字符串情况下的SAM解法）。

SAM解法的优点：

时间复杂度是O(N)的，在数据量大的时候会快很多，可以通过数据更强的SPOJ.com - Problem LCS2

题意：

输入k个字符串，求这k个字符串间的最长公共子串的长度。

解法一：

原地址：后缀自动机 (SAM) - OI Wiki (oi-wiki.org)

我的AC代码：
//
// Created by 15411 on 2024/8/30.
//
#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
using namespace std;
const int N=2e5+7;
int k,ans;//字符串数量
string s,t;
namespace SAM{
    struct node{
        int link,len;
        int son[27],vst[10];//记录十种&的可能
    }t[N<<1];
    int sz,last,kk;
    bitset<N<<1>vst;
    void newNode(int length){
        t[++sz].len=length;
        t[sz].link=-1;
        memset(t[sz].son,0,sizeof(t[sz].son));
        memset(t[sz].vst,0,sizeof(t[sz].vst));
    }
    void init(){
        for(int i=0;i<=sz;i++)vst[i]=false;
        sz=-1;last=0;ans=0;kk=-1;
        newNode(0);
    }
    void insert(int c){
        newNode(t[last].len+1);
        if(c<0){
            vst[sz]=true;
            t[sz].vst[++kk]=true;
            c=26;//&
        }
        int p=last,cur=sz;
        while(p!=-1&&!t[p].son[c])
            t[p].son[c]=cur,p=t[p].link;
        if(p==-1)
            t[cur].link=0;
        else{
            int q=t[p].son[c];
            if(t[q].len==t[p].len+1)
                t[cur].link=q;
            else{
                newNode(t[p].len+1);
                int nq=sz;
                memcpy(t[nq].son,t[q].son,sizeof(t[q].son));
                memcpy(t[nq].vst,t[q].vst,sizeof(t[q].vst));
                if(vst[q])vst[nq]=true;
                t[nq].link=t[q].link;
                t[cur].link=t[q].link=nq;
                while(p!=-1&&t[p].son[c]==q)
                    t[p].son[c]=nq,p=t[p].link;
            }
        }
        last=cur;
    }
    vector<int>G[N<<1];
    void dfs(int now){
        for(auto next:G[now]){
            dfs(next);
            for(int i=0;i<k;i++){
                if(t[next].vst[i])
                    t[now].vst[i]=true;
            }
        }
    }
    void Find(int now){//查询当前点的子中有几个&
        vst[now]=true;
        for(int i=0;i<27;i++){
            if(!t[now].son[i])continue;
            int cd=t[now].son[i];
            if(!vst[cd])Find(cd);

            for(int j=0;j<k;j++) {
                if(t[cd].vst[j])
                    t[now].vst[j]=true;
            }
        }
        int cnt=0;
        for(int i=0;i<k;i++)if(t[now].vst[i])cnt++;
        if(cnt==k)
            ans=max(ans,t[now].len);
    }
    void query(){
        for(int i=0;i<=sz;i++)G[i].clear();
        for(int i=1;i<=sz;i++)G[t[i].link].push_back(i);
        dfs(0);
        Find(0);
    }
}
void solve() {
    cin>>k;
    s.clear();
    for(int i=1;i<=k;i++){
        cin>>t;
        s+=t;
        s+='&';
    }

    int len=(int)s.size();
    SAM::init();
    for(int i=0;i<len;i++){
        SAM::insert(s[i]-'a');
    }
    SAM::query();
    cout<<ans<<endl;
}
signed main(){
    ios::sync_with_stdio(false);//cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

解法二

原地址：Longest Common Substring II SPOJ - LCS2 （后缀自动机） - Jiaaaaaaaqi - 博客园 (cnblogs.com)
我的AC代码：
//
// Created by 15411 on 2024/8/30.
//
#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
using namespace std;
const int N=2e5+20;
const int INF=1e9+7;
int k,LCM;//字符串数量
string s;
char t[N];
namespace SAM{
    struct node{
        int link,len;
        int cnt,lcm_last,lcm_now;//之前串的每个点的LCM取min，当前串每个点的LCM取max
        int son[26];
    }t[N<<1];
    int sz,last;
    void newNode(int length){
        t[++sz].len=length;
        t[sz].link=-1;t[sz].cnt=1;t[sz].lcm_last=INF;
        memset(t[sz].son,0,sizeof(t[sz].son));
    }
    void init(){
        sz=-1;last=0;
        newNode(0);
    }
    void insert(int c){
        newNode(t[last].len+1);
        int p=last,cur=sz;
        while(p!=-1&&!t[p].son[c])
            t[p].son[c]=cur,p=t[p].link;
        if(p==-1)
            t[cur].link=0;
        else{
            int q=t[p].son[c];
            if(t[q].len==t[p].len+1)
                t[cur].link=q;
            else{
                newNode(t[p].len+1);
                int nq=sz;
                memcpy(t[nq].son,t[q].son,sizeof(t[q].son));
                t[nq].link=t[q].link;
                t[cur].link=t[q].link=nq;
                while(p!=-1&&t[p].son[c]==q)
                    t[p].son[c]=nq,p=t[p].link;
            }
        }
        last=cur;
    }
    int ans[N];
    vector<int>G[N<<1];
    void dfs(int now){
        for(auto next:G[now]){
            dfs(next);
            t[now].lcm_now=max(t[now].lcm_now,t[next].lcm_now);
            t[now].lcm_now=min(t[now].len,t[now].lcm_now);//父节点虽然匹配上了，但要防止越界
        }
    }
    void init2(){
        for(int i=0;i<sz;i++)G[i].clear();
        for(int i=1;i<=sz;i++)G[t[i].link].push_back(i);
    }
    void query(char* s) {
        for (int i = 0; i <= sz; i++)t[i].lcm_now = 0;
        int now = 0, n = (int) strlen(s);
        for (int i = 0; i < n; i++) {
            if (t[now].son[s[i] - 'a']) {
                now = t[now].son[s[i] - 'a'];
                ans[i + 1] = ans[i] + 1;
            } else {
                while (now != -1 && !t[now].son[s[i] - 'a'])
                    now = t[now].link;
                if (now == -1) {
                    now = 0;
                    ans[i + 1] = 0;
                } else {
                    ans[i + 1] = t[now].len + 1;
                    now = t[now].son[s[i] - 'a'];
                }
            }
            t[now].lcm_now = max(t[now].lcm_now, ans[i + 1]);
        }
        dfs(0);
        for (int i = 0; i <= sz; i++) {
            if (!t[i].lcm_now)continue;
            t[i].cnt++;//记得统计这个点是不是被匹配了k次
            t[i].lcm_last = min(t[i].lcm_last, t[i].lcm_now);
        }
    }
    void query(){
        LCM=0;
        for(int i=0;i<=sz;i++){
            if(t[i].cnt==k)
                LCM=max(LCM,t[i].lcm_last);
        }
    }
}
void solve() {
    cin>>k>>s;
    int len=(int)s.size();
    SAM::init();
    for(int i=0;i<len;i++)SAM::insert(s[i]-'a');
    SAM::init2();
    for(int i=2;i<=k;i++){
        cin>>t;
        SAM::query(t);
    }
    SAM::query();
    if(k==1)
        LCM=len;
    cout<<LCM;
}
signed main(){
    ios::sync_with_stdio(false);//cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

思路3：

二分长度+哈希验证。

我的二分哈希代码：

//
// Created by 15411 on 2024/8/31.
//
#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
using namespace std;
const int N=2e4+7;
namespace Hash{
    const int base1=13331,MOD1=1e9+7;
    int P1[N],H1[N];
    void init(char* s,int len){
        P1[0]=1;H1[0]=s[0]-'a';
        for(int i=1;i<len;i++){
            H1[i]=(H1[i-1]*base1)%MOD1+(s[i]-'a');H1[i]%=MOD1;
            P1[i]=(P1[i-1]*base1)%MOD1;
        }
    }
    int get_hash(int L,int R){
        int ret=H1[R]-H1[L-1]*P1[R-L+1];
        ret=(ret%MOD1+MOD1)%MOD1;
        return ret;
    }
}
char s[11][N];
int k;
bool yz(int LEN){
    map<ll,bool>vst[2];
    ll len=(ll)strlen(s[1]);
    Hash::init(s[1],len);
    for(int L=0,R=L+LEN-1;R<len;R++,L++){
        int H_now=Hash::get_hash(L,R);
        vst[1&1][H_now]=true;
    }
    for(int i=2;i<=k;i++){
        len=(ll)strlen(s[i]);
        Hash::init(s[i],len);
        vst[i&1].clear();
        for(int L=0,R=L+LEN-1;R<len;R++,L++){
            int H_now=Hash::get_hash(L,R);
            if(vst[!(i&1)][H_now])
                vst[i&1][H_now]=true;
        }
    }
    if(!vst[k&1].empty())return true;
    return false;
}
void solve() {
    cin>>k;
    ll l=0,r=2e5+7;
    for(int i=1;i<=k;i++){
        cin>>s[i];
        r=min(r,(ll)strlen(s[i]));
    }
    while(l<r){
        ll mid=(l+r+1)>>1;
        if(yz(mid))
            l=mid;
        else
            r=mid-1;
    }
    cout<<l<<endl;
}

signed main(){
#ifdef ONLINE_JUDGE
#else
    freopen("test.in", "r", stdin);
    freopen("test.out", "w", stdout);
#endif
    ios::sync_with_stdio(false);//cin.tie(0);cout.tie(0);
//    ll t;cin>>t;while(t--)
        solve();
    return 0;
}

东方延绪z
关注
常用的字符串哈希函数
dvlinker的技术专栏
01-23 1万+
本文将介绍什么是字符串哈希函数，字符串哈希函数常见用法，以及字符串哈希函数的实现原理和常用算法。
代码随想录——JAVA算法题——哈希表
最新发布
weixin_55902321的博客
09-06 564
给定两个字符串和，编写一个函数来判断是否是的。
公共子串计算
ren__wei_的博客
05-21 722
1.题目描述 给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。 注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。 例如： 输入： asdfas werasdfaswer 输出： 6 2.思路分析 这里要注意，这是最大公共子串，而不是公共子序列。这就要求，符合要求的元素之间都是连续的。 我们用动态规划的思想来做题。 针对一个状态F(i, j)，i是第一个字符串的第i个元素，j是第二个字符串中的第j个元素。 举一个例子： F(1， 1) = 0，因为第一个字符串的
华为机试题75-公共子串计算
qq_47307864的博客
05-04 332
描述 给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。 注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。 数据范围：字符串长度：1≤s≤150 进阶：时间复杂度：O(n^3) ，空间复杂度：O(n) 输入描述： 输入两个只包含小写字母的字符串 输出描述： 输出一个整数，代表最大公共子串的长度 示例1 输入： asdfas werasdfaswer 输出： 6 解题思路： 直接暴力求解了，没用动态规划。 先将两个字符串的短串和
华为机试HJ75：公共子串计算
热门推荐
翟天保的博客
09-18 1万+
C++实现——公共子串计算
华为机试：公共子串计算
lzyhhhhh的博客
09-03 501
一、题目： 描述 给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。 注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。 输入描述： 输入两个只包含小写字母的字符串 输出描述： 输出一个整数，代表最大公共子串的长度 二、输入输出示例： 三、代码： #include<iostream> using namespace std; #include<string> #include<vector> int ma
c代码-洛谷压缩数
07-14
【洛谷压缩数】是一种在计算机编程中用于高效存储整数序列的方法，特别是在解决算法竞赛问题时被广泛采用。洛谷压缩数的概念来源于知名的在线编程平台洛谷（LeetCode），它旨在减少内存占用并提高计算速度。这个压缩...
哈希——字符串
m0_62450783的博客
02-20 1333
字符串哈希一共有三种，自然溢出法，单哈希，双哈希，本文用一个例题来解释。 字符串哈希： 将一段字符串进行加密，比较常用的是进制转化，将每一个字符看成一个进制，转化成一个base进制，比如把一个数由二进制变成十进制，转化完之后的那个数就是那个字符串的hash值。 洛谷的P3370题： 自然溢出法(常用)： 顾名思义，就是利用溢出这一特性来进行的，代码： #include<iostream> #include<string.h> #inc...
哈希表(理论剖析+代码实现)
修行的凡人的博客
10-16 4091
基于著名书籍和自我研究得出的哈希表理论剖析与代码实现
【哈希冲突解决】线性探测再散列和二次探测再散列
不忘初心，护天下安全！
08-10 5528
Hashing）是计算机科学中一种对资料的处理方法，通过某种特定的函数/算法（称为散列函数/算法）将要检索的项与用来检索的索引（称为散列，或者散列值）关联起来，生成一种便于搜索的数据结构（称为散列表）。二次再散列法是指第一次散列产生哈希地址冲突，为了解决冲突，采用另外的散列函数或者对冲突结果进行处理的方法。...
面试题之求两个字符串的最大公共子串
u011484045的专栏
09-10 5964
面试题之求两个字符串的最大公共子串 字符串的题目感觉真的好难，关于字符串的题目，需要弄懂题意的思路，思路对了，编程就ok了(好像是废话哦)。下面分析下求两个字符串的最大公共子串的解题思路。 首先我们确定一个基准串和查找串，基准串就是两个字符串中长度长的字符串，查找串就是那个短的串。我们从查找串的头部开始，在基准串的尾部开始查找，若查到了，就给数组sign[j]赋值，j是基准串的下标，表示基
java公共子串计算
橘白呀啊的博客
05-21 587
文章目录题目描述解题思路代码如下 题目描述 给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。 注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。 eg: 输入： asdfas werasdfaswer 输出： 6 以下是本篇文章正文内容，下面案例可供参考 解题思路 此题可采用动态规划 x(i): 字符串第i个字符 y(j): 字符串第j个字符 状态： F[i,j]：表示以x(i),y(j)结尾的最大子串长度 状态转移方程： x(i) != y(j).
获取两个字符串的最大公共子串
金玉满堂的博客
11-22 1548
1.思路 先找到每个字符串的所有的子串，存放到集合中 2.两个集合求交集 intersection 3.然后找到交集中 最长的那个元素 第一步中是求字符串公共子集的方法 def son_str(s): #s = ‘abcab’ list1 = list(set(s[i:j] for i in range(len(s)) for j in range(i, len(s) + 1))) print(list1) return set(list1) 第二步骤 定义的两个集合，使用intersection 生成公
【笔试题分析】求两个字符串中最大公共子串的字符数
qq_22744093的博客
03-07 384
题目：求两个字符串中最大公共子串的字符数，以下是一种解法，代码如下： import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String string1 ...
求两个字符串的最大公共字串问题
menghuanxiy的专栏
08-21 1142
以下题目来自阿里2015校园招聘、牛客网。 给定一个query和一个text，均由小写字母组成。要求在text中找出以同样的顺序连续出现在query中的最长连续字母序列的长度。例如，query为 "acbac",text为"acaccbabb",那么text中的"cba"为最长的连续出现在query中的字母序列，因此，返回结果应该为其长度3。请注意程序效率。 假设text的长度为m，que
最长公共子串：给定两个字符串str1和str2,输出两个字符串的最长公共子串，如果最长公共子串为空，输出-1。
兰斯兰斯
04-23 7899
最长公共子串和最长最长公共子序列不同的是 最长公共子串要求必须是连续的。 题目 给定两个字符串str1和str2,输出两个字符串的最长公共子串，如果最长公共子串为空，输出-1。 输入描述: 输入包括两行，第一行代表字符串srr1，第二行代表字符串str2。\left( 1\leq length(str1),length(str2) \leq 5000 \right)(1≤length(str1),...
小乐乐匹配字符串（最长公共子序列）
ccsu_deer
12-03 475
链接：https://ac.nowcoder.com/acm/contest/301/E 来源：牛客网 小乐乐匹配字符串 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld 题目描述 小乐乐有字符串str1,str2。 小乐乐想要给他们找朋友。 小乐乐想知道在这两个字符串中最多能匹配出多长的...
java中两个字符串匹配的个数_java实现字符串匹配问题之求两个字符串的最大公共子串...
weixin_42392425的博客
02-24 416
转载请注明出处:http://blog.csdn.net/xiaojimanman/article/details/38924981 近期在项目工作中有一个关于文本对照的需求,经过这段时间的学习,总结了这篇博客内容:求两个字符串的最大公共子串. 算法思想:基于图计算两字符串的公共子串.详细算法思想參照下图: 输入字符串S1:achmacmh 输入字符串S2:macham 1)第a步,是将字符...
二分三分哈希详解：搜索、排序与散列技术
二分三分哈希是一种在数据结构和算法中常用的搜索技术，它结合了二分查找和散列的概念。首先，我们来看看二分查找。 **二分查找**（Binary Search）是一种在有序数组中查找特定元素的高效算法。它的工作原理基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东方延绪z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值