HDU 1403 Longest Common Substring

最新推荐文章于 2025-08-07 10:54:13 发布
原创 最新推荐文章于 2025-08-07 10:54:13 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#优化 #each #数据结构 #测试 #output #string

Longest Common Substring

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1453    Accepted Submission(s): 419

Problem Description
Given two strings, you have to tell the length of the Longest Common Substring of them.

For example:
str1 = banana
str2 = cianaic

So the Longest Common Substring is "ana", and the length is 3.
 


 

Input
The input contains several test cases. Each test case contains two strings, each string will have at most 100000 characters. All the characters are in lower-case.

Process to the end of file.
 


 

Output
For each test case, you have to tell the length of the Longest Common Substring of them.
 


 

Sample Input 
   

    banana
cianaic
 


 

Sample Output 
   

    3
   

   

     
   

   

    今次系第一次用倍增算法构建后缀数组，我写既呢个其实比较好理解，哈哈，因为我好老实甘对SA两个关键字排序鸟，无花巧野，好直接，不过自己写既效率真系不敢恭维，可能直接过头………………{=    =}
   

   

    
38986192011-05-02 09:27:06Accepted14031015MS8056K2800 BG++10SGetEternal{（。）（。）}!

   

   

    
38986642011-05-02 09:45:07Accepted1403968MS8060K2901 BG++10SGetEternal{（。）（。）}!

   

   

    
38986672011-05-02 09:45:32Accepted1403843MS6844K2901 BG++10SGetEternal{（。）（。）}!

   

   

    
38987502011-05-02 10:09:18Accepted1403828MS6852K3481 BG++10SGetEternal{（。）（。）}!

   

   

    
38989732011-05-02 11:06:51Accepted1403750MS6964K2441 BG++10SGetEternal{（。）（。）}!

   

   

    
39006662011-05-02 20:02:15Accepted1403734MS6900K2827 BC++10SGetEternal{（。）（。）}!

   

   

    
39008742011-05-02 20:42:53Accepted1403484MS6900K2496 BC++10SGetEternal{（。）（。）}!

   

   

    
39008952011-05-02 20:45:23Accepted1403468MS6900K2258 BC++10SGetEternal{（。）（。）}!

   

   

    
39009282011-05-02 20:49:18Accepted140393MS6756K2329 BC++10SGetEternal{（。）（。）}!

   

   

    93ms！！！！！感动到内牛满面！！！！！！！！！！{=       =} 
   

   

    下面献上优化代码，终于可以做模版鸟可以。
   

   

     
   

   

    #include<iostream>
#include<string>
using namespace std;
#define MAXI 200011
   

   

    char str[MAXI];
int *sa = new int [MAXI];
int *tsa = new int [MAXI];
int *rank = new int [MAXI];
int *k1 = new int [MAXI];
int *k2 = new int [MAXI];
int *t, l, sigm, hash[MAXI], h[MAXI], height[MAXI];
   

   

    void RS(int *k)
{
    int i;
    for (i = 0; i < sigm; i++) *(hash + i) = 0;
    for (i = 0; i < l; i++) hash[k[sa[i]]]++;
    for (i = 1; i < sigm; i++) *(hash + i) += *(hash + i - 1);
    for (i = l - 1; i >= 0; i--) tsa[--hash[k[sa[i]]]] = *(sa + i);
    t = sa; sa = tsa; tsa  = t;
}
   

   

    void CSA()
{
 int i, j, k;
 for (i = 0; i < l; i++) 
 {
  *(sa + i) = i;
  *(k1 + i) = *(str + i);
 }
 for (RS(k1), j = 1; j < l && sigm < l; j *= 2, sigm++)
 {
  for (k =0,  i = l - j; i < l; i++) *(tsa + k++) = i;
  for (i = 0; i < l; i++)
   if (sa[i] >= j) *(tsa + k++) = *(sa + i) - j;
  for (i = 0; i < l; i++) *(k2 + i) = *(k1 + *(sa + i)); 
   

   

     
   

   

      //参考baidu代码！终于明白神马意思鸟…………如果明白你原理既话，就知道，我初先系先求排名
   

   

      //再求SA，甘样就吾可以用sigm < l去优化（加左从468ms变成93ms）。
   

   

      //因为先求排名就吾可以充分利用上一次k1，其实对第二关键字（i + j）排序结果可以直接从上一次
   

   

      //SA得出，原理其实同埋我原先果个代码一样，将（i + j） > l既下标直接前置，上次系先名次前置
   

   

      //今次直接用TSA前置，甘样就直接得出key2排序结果鸟！！！！！
   

   

    
  t = sa; sa = tsa; tsa = t;  //等价于更新左SA数组
  RS(k1), t = k1, k1 = k2, k2 = t; //再对key1排序；
  for (sigm = k1[sa[0]] = 0, i = 1; i < l; i++) //求名次
   if (k2[sa[i]] == k2[sa[i - 1]] && k2[sa[i] + j] == k2[sa[i - 1] + j])
    *(k1 + *(sa + i)) = sigm;
   else *(k1 + *(sa + i)) = ++sigm;
   

   

      //有人可能会问，点解直接sa[i] + j 唔会超界，其实就系最后一个字符'/0’起作用鸟，如果长度超界
   

   

      //甘样每次比较长度如果达到最后一个字符'/0'，k2[sa[i]]必定不等于k2[sa[i - 1]],因为距地同
   

   

      //系一个串度，长度必然吾同，所以必然会比较到'/0'即必会分出大小，所以&&后面判断唔会执行
   

   

      //唔会发生超界情况{^____^}，之所以交换k1， k2就系为左保持循环不变式，用k1求出迭代结果。
 }
 for (i = 0; i < l; i++) *(rank + *(sa + i)) = i; //因为先求SA，所以rank要另外求
}
   

   

    void CHA()
{
    int i, j, k, add;
   

   

        for (i = 0; i < l; i++)
    {
        if (rank[i] == 0) 
        { h[i] = 0; continue; }
        j = rank[i]; k = j - 1;
        if (i ==0 || h[i - 1] <= 1) add = 0;
        else add = h[i - 1] - 1;
        while (str[sa[j] + add] == str[sa[k] + add]) add++;
        height[rank[i]] = h[i] = add;
    }
}
   

   

    int main()
{
    int i, T, l1, l2;
    char tbuf[MAXI];
   

   

        //scanf("%d", &T);
    //while (T--)
    while (scanf("%s", tbuf) != EOF)
    {
        l1 = strlen(tbuf);
        for (i = l = 0; i < l1; i++) str[l++] = tbuf[i];
        str[l++] = '#';
        scanf("%s", tbuf);
        l2 = strlen(tbuf);
        for (i = 0; i < l2; i++) str[l++] = tbuf[i];
        str[l++] = 0;
        sigm = 256;
        CSA(), CHA();
        for (sigm = 0, i = 1; i < l; i++)
            if ((sa[i] < l1 && sa[i - 1] > l1) || (sa[i - 1] < l1 && sa[i] > l1))
                if (height[i] > sigm) sigm = height[i];
        printf("%d/n", sigm);
    }
   

   

        return 0;
}
   

   

     
   

   

    #include<iostream.h>
#include<stdio.h>
#include<string.h>
#define MAXI 200011
   

   

    char str[MAXI];
int *sa = new int [MAXI];
int *tsa = new int [MAXI];
int *rank = new int [MAXI];
int *k1 = new int [MAXI];
int *k2 = new int [MAXI];
int *t, l, sigm, hash[MAXI], h[MAXI], height[MAXI];
   

   

    void Print(int *s, int l)//用于测试｛=   =｝
{
 int i;
 for (i = 0; i < l; i++) printf("%d ", *(s + i));
 putchar('/n');
}
   

   

    void PrintSA()//测试输出too｛= =｝
{
 int i;
 for (i = 0; i < l; i++)
  printf("%4d : %s/n", sa[i], str + sa[i]);
}
   

   

    void RS(int *k)//Radix Sort 其实通过多次系计数排序调整相对位置既排序，我觉得可以理解为降维
{
 int i;
   

   

     for (i = 0; i < sigm; i++) *(hash + i) = 0;
 for (i = 0; i < l; i++) hash[k[sa[i]]]++;
 for (i = 1; i < sigm; i++) *(hash + i) += *(hash + i - 1);
 for (i = l - 1; i >= 0; i--) tsa[--hash[k[sa[i]]]] = *(sa + i);
 t = sa; sa = tsa; tsa  = t;
}
   

   

    void CSA()//Construct Suffix Array 构建后缀数组也
{
 int i, j;
   

   

     for (i = 0; i < l; i++) 
 {
  *(sa + i) = i;           //SA储存下标，后缀数组就系按照下标排序d
  *(k1 + i) = *(str + i);  //其实大家可以将Str理解为第一次排序既关键字，姐系rank['a'] = 0…………
 }
   

   

     RS(k1);           //先求出SA0
 for (rank[sa[0]] = 0, i = 1; i < l; i++)
  if (k1[sa[i]] == k1[sa[i - 1]])
   rank[sa[i]] = rank[sa[i - 1]];
  else rank[sa[i]] = rank[sa[i - 1]] + 1;
 for (j = 1; j < l; j <<= 1, sigm++) //sigm其实就系∑｛0o0｝关键字集合最大值，用黎优化左15ms{o0o}
 {
  for (i = 0; i < l; i++) //k1,k2,其实就系Rank
    i同埋Rank
    i+j，同时又系关键字key。
   if (i + j < l)
    k2[i] = rank[i + j];  //第二关键字其实已经可以从Rank求出，原理应该唔洗我讲拉下哇，写得甘直接{= =}

   else k2[i] = 0;        //对于i + j >= l， k2[i] = 0可以理解为保证SA
    i+1
    中最小既先摆前面
   

   

      t = k1; k1 = rank; rank = t;//呢个就系动态数组既好处直接交换k1，rank
  RS(k2); RS(k1);         //LSD，先拍第二关键字Rank
    i+j
    再排第一关键字,直接，我捻就系尼度慢左｛= 。=｝
  for (sigm = 0, i = 1; i < l; i++) //排名次兼更新sigm，排名规则百度大把。
  {
   if (k1[sa[i]] == k1[sa[i - 1]] && k2[sa[i]] == k2[sa[i - 1]])
    rank[sa[i]] = rank[sa[i - 1]];
   else rank[sa[i]] = rank[sa[i - 1]] + 1;
   if (sigm < rank[sa[i]]) sigm = rank[sa[i]];
  }
 }
 //Print(sa, l);
 //PrintSA();
}
   

   

    void CHA()//Construct Height Array， 构建Height数组也，其中height = LCP（sa[i]， sa[i - 1]）；
{
 int i, j, k, add;
   

   

     for (i = 0; i < l; i++)
 {
  if (rank[i] == 0)    //排名第0LCP（0， -1）肯定为0啦，直接continue
  { h[i] = 0; continue; }
  j = rank[i]; k = j - 1; 
   

   

      //尼度其实有dKMP既味道我觉得，因为SA中，h[i]>= h[i - 1] - 1，可以想象下，有个感性形象既认识
  if (i ==0 || h[i - 1] <= 1) add = 0;//呢个唔洗讲啦下哇{-_-|||}
  else add = h[i - 1] - 1;
  while (str[sa[j] + add] == str[sa[k] + add]) add++;//顺次比较
  height[rank[i]] = h[i] = add; 
   

   

      //height[rank[i]] = h[i], height[i] = h[sa[i]]，同SA，Rank关系一样，都系互逆数组
   

   

      //呢d比较复杂既下标操作，用实例操操就明白鸟｛= =｝
 }
 
 //Print(height, l);
}
   

   

    int main()
{
 int i, T, l1, l2;
 char tbuf[MAXI];
   

   

     //scanf("%d", &T);
 //while (T--)
 while (scanf("%s", tbuf) != EOF)
 {
   

   

      //先合并字符串，再构建SA
  l1 = strlen(tbuf);
  for (i = l = 0; i < l1; i++) str[l++] = tbuf[i];
  str[l++] = '#'; //分隔符#，同后面‘ ’作用差唔多
  scanf("%s", tbuf);
  l2 = strlen(tbuf);
  for (i = 0; i < l2; i++) str[l++] = tbuf[i];
  str[l++] = 0;    
   

   

      //初先我吾明白点解最后要加一个最小关键字，但系我通过一个范例AAAAAA终于明白鸟，就系保证比较有结果也
  sigm = MAXI;
  CSA();
  CHA();
  for (sigm = 0, i = 1; i < l; i++) //sigm转职储存最大公共子串
   if ((sa[i] < l1 && sa[i - 1] > l1) || (sa[i - 1] < l1 && sa[i] > l1))//唔系同一个串
    if (height[i] > sigm) sigm = height[i]; //且大于当前最大值
  printf("%d/n", sigm);
 }
   

   

     return 0;
}
   

   

     
   

   

    睇住baidu后缀数组代码真系好鬼死蛋痛…………好难睇下。
   

   

    关于我对后缀数组既理解会另外写系数据结构9up度，我会尽量用写得容易理解d，少d理论，多d图片，平凡d，造福人类。
   

   

     
   

   

    ｛= =*｝Y
   

   

     
   

   

    经过左今次优化之后我觉得…………可能对key1排序都可以好似key2甘直接得出！！
   

   

    不过都系搞下其他先啦，因为就快省赛鸟………………
【ACM刷题专题】这个假期一起来刷题把，刷完冲击区域赛，刷完拿不到奖随便打！
超逸の学习技术博客
02-07 8483
文章目录1、引言2、专题分享2.1 专题一 简单搜索2.2 专题二 搜索进阶2.3 专题三 Dancing Links舞蹈链2.4 专题四 最短路练习2.5 专题五 并查集2.6 专题六 最小生成树2.7专题七 线段树2.8 专题八 生成树2.9 专题九 连通图2.10 专题十 匹配问题2.11 专题十一 网络流2.12 专题十二 基础DP12.13 专题十三 基础计算几何2.14 专题十四 数论...
kuangbin带你飞 专题1-23 题单
HelloACM_ICPC的博客
01-27 2862
kuangbin大神，对于打过ACM比赛的ACMer，无人不知无人不晓。 在此，附上vjudge平台上一位大神整理的[kuangbin带你飞]专题目录链接。 [kuangbin带你飞专题目录1-23] : https://vjudge.net/article/187 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That...
hdu1403Longest Common Substring
_zidaoziyan的博客
09-18 540
Longest Common Substring Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 5144    Accepted Submission(s): 1811 Problem Description Giv
HDU1403 Longest Common Substring —— 后缀数组
A man can be destroyed, but not defeated.
08-27 446
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1403 Longest Common Substring Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6792
HDU1403 Longest Common Substring
eeeaaaaa的专栏
07-09 462
Longest Common Substring Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3851    Accepted Submission(s): 1443 Problem Description Given
hdu 1403 Longest Common Substring
weixin_30662011的博客
07-07 90
我是不是真的需要学学后缀数组了，这个题我是用后缀自动机写出来的。写的比较辛苦吧，不过对后缀自动机的理解又进了一步。不废话了，题意是让你求两个字符串的最长公共子串的长度。 现在贴上我的代码： View Code #include <algorithm> #include <iostream> #include <cstdlib> #include...
Hdu1403 Longest Common Substring
weixin_30539625的博客
03-11 92
Longest Common Substring Time Limit: 8000/4000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 7335Accepted Submission(s): 2580 Problem Description Given ...
HDU1403-Longest Common Substring
wang_128的博客
12-01 395
Longest Common Substring                                                                            Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
hdu1403 Longest Common Substring
weixin_30872733的博客
03-30 101
地址：http://acm.split.hdu.edu.cn/showproblem.php?pid=1403 题目： Longest Common Substring Time Limit: 8000/4000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 6296...
HDU1403 Longest Common Substring【后缀数组】
MaJorieL
07-13 156
Time Limit: 8000/4000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others) Problem Description Given two strings, you have to tell the length of the Longest Common Substring of them. Fo...
HDU 1403 Longest Common Substring
涅槃phy的专栏
02-16 687
ProblemDescription Given two strings,you have to tell the length of the Longest Common Substring of them. For example: str1 = banana str2 = cianaic So the Longest Common Substring is "ana", a
老鱼的-kuangbin专题题解
DeathYmz的博客
04-07 1584
kuangbin专题问题一览 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That Cow POJ 3279 Fliptile POJ 1426 Find The Multiple POJ 3126 Prime Path POJ 3087 Shuffle’m Up POJ 3414 Pots FZU...
【刷题计划1】【poj分类转载】
loving coding
08-19 1341
----------------2018.4.10更新-----------------------原本这只是暑假刷题计划，后来因为某些原因，自己就不是很努力的刷题，现在情况有变，so，重新继续咯~下个月26号省赛，扣去中间实训的一周时间和几次校赛，大概只有一个月时间。目前计划是，每天基础算法题+cf上3题，专业课也先停了，自己这段时间只想认真写题。昨天晚上又失眠了，虽然我知道保证训练效率的关键是...
后缀自动机（SAM）学习指南
Azarath Metrion Zinthos
07-20 5198
*在学习后缀自动机之前需要熟练掌握WA自动机、RE自动机与TLE自动机* 什么是后缀自动机 后缀自动机 Suffix Automaton （SAM） 是一个用 O(n) 的复杂度构造，能够接受一个字符串所有后缀的自动机。 它最早在陈立杰的 2012 年 noi 冬令营讲稿中提到。 在2013年的一场多校联合训练中，陈立杰出的 hdu 4622 可以用 SAM 轻松水过，由此 S
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 627
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 253
/队列: 先进先出。
【数据结构初阶】--顺序表（二）
yhrxh_ymq的博客
08-05 816
本文详细讲解了顺序表的实现方法，重点介绍了尾插、头插、尾删和头删四个核心操作。内容包含：1）尾插操作的动态扩容机制，采用2倍扩容策略；2）头插操作需要整体后移元素；3）尾删只需修改size值；4）头删需要前移元素。文中提供了完整的C语言实现代码，并通过测试用例验证了各功能的正确性。最后分析了时间复杂度：尾插/删为O(1)，头插/删为O(n)，说明顺序表更适合频繁操作尾部数据的场景。作者预告后续将继续完善顺序表的其他操作接口。
数据结构——B-树、B+树、B*树
最新发布
学习日记
08-07 844
在之前，我们已经学习了很多的数据结构，当我们处理海量数据时，选择合适的数据结构变得至关重要，对于不同的数据结构它们的搜索效率也存在着很大的差异。如下种类数据格式时间复杂度顺序查找无要求O(N)二分查找有序O(log⁡2N)二叉搜索树无要求O(N)二叉平衡树(AVL树和红黑树)无要求O(log⁡2N)哈希无要求O(1)以上结构适合用于数据量相对不是很大，能够一次性存放在内存中，进行数据查找的场景。
HDU1020解题报告深度解析
资源摘要信息:"HDU1020解题报告" 知识点一：HDU平台介绍 HDU（HANGZHOU DIZHI UNIVERSITY Online Judge）是杭州电子科技大学的一个在线评测系统，通常简称为HDU OJ或HDU。它是一个提供编程题目的在线平台，广泛用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值