精华内容
下载资源
问答
  • 对于还了解LeetCode同学,那比较厉害了,估计离大厂还有一步距离! LeetCode,让程序员进阶在线平台,找工作备战名企技术面试!(文末阅读原文到达学习平台) 本公众号之前陪伴了几期LeetCode打卡之...

    对于还不了解LeetCode的同学,那比较厉害了,估计离大厂还有一步距离!

     

    LeetCode,让程序员进阶的在线平台,找工作备战名企技术面试!(文末阅读原文到达学习平台)

    本公众号之前陪伴了几期LeetCode的打卡之旅,

    
     

    Python版LeetCode1.两数之和
    Python版LeetCode3.无重复字符的最长子串
    Python版LeetCode4.两个排序数组的中位数
    Python版LeetCode5. 最长回文子串
    Python版LeetCode7. 反转整数
    Python版LeetCode8. 字符串转整数 (atoi)
    Python版LeetCode9. 回文数
    Python版LeetCode11. 盛最多水的容器
    Python版LeetCode14. 最长公共前缀
    Python版LeetCode15. 三数之和
    Python版LeetCode16. 最接近的三数之和
    Python版LeetCode17. 电话号码的字母组合

    Python版LeetCode18. 四数之和

     

    如今,小编有更重要的事情要做,只能丢下一份“武功秘籍”,它可以陪伴你度过至少3个月了,因为我们整理了665份LeetCode的参考答案。

     

    if 你是如下情况之一:

    1. python小白,想要python进阶

    2. 想要通过名企的python笔试获得高薪

    3. 有单纯的喜欢刷题打怪的爱好

    这份资料我们一定要送给你!

    加微信ai_hellohello ,备注“leetcode”

    展开全文
  • 1.10.4 使用EXCEPT和INTERSECT返回不重复的或匹配的行 38 1.11 汇总数据 40 1.11.1 使用CUBE汇总数据 40 1.11.2 使用ROLLUP来汇总数据 42 1.11.3 使用分组集创建自定义汇总 43 1.11.4 展现GROUPING生成...
  • 以下内容引自2009国家集训队论文《后缀数组——处理字符串有力工具》 罗穗骞 最长公共前缀: ...不可重叠最长重复子串: 二分答案kkk,把问题变成判定性问题:判断是否存在两个长度为 k 子串...

    以下内容引自2009国家集训队论文《后缀数组——处理字符串的有力工具》 罗穗骞

    在这里插入图片描述
    在这里插入图片描述

    最长公共前缀:

    height数组的区间最小值。


    单个字符串的相关问题

    可重叠最长重复子串:

    子串就是后缀的一个前缀,所以重复子串就是两个后缀的公共前缀,只需求两个后缀的最大公共前缀,就是height数组的最大值。

    不可重叠最长重复子串:

    二分答案kk,把问题变成判定性问题:判断是否存在两个长度为 k 的子串是相同的,且不重叠。将height按照大小分组,使得每一组的height值都大于等于k,那么最长公共前缀大于等于k的两个后缀只可能出现在同一组中,只需要是否存在某一组后缀中sa的最大值与最小值之差大于等于k。

    可重叠k次最长重复子串:

    同样二分答案后分组,检测是否存在某一组的后缀个数大于等于k。
    或在height数组中选一段长度为k-1的区间,取区间最小值的最大值。

    不相同子串个数:

    每个子串一定是某个后缀的前缀,那么原问题等价于求所有后缀之间的不相同的前缀的个数。按照后缀排序后的顺序依次考虑,对于第k个后缀suffix(sa[k]),它将产生n-sa[k]+1个前缀,但其中有height[k]个是和前面相同的,将n-sa[k]+1-height[k]累加即为答案。

    最长回文子串:

    穷举每一位,然后计算以这个字符为中心的最长回文子串。注意这里要分两种情况,一是回文子串的长度为奇数,二是长度为偶数。两种情况都可以转化为求一个后缀和一个反过来写的后缀的最长公共前缀。具体的做法是:将整个字符串反过来写在原字符串后面,中间用一个特殊的字符隔开。

    连续重复子串:

    问题描述:已知字符串S是由子串L重复R次得到的,求R的最大值。
    穷举字符串 S 的长度 k,然后判断是否满足。判断的时候,先看字符串 L 的长度能否被 k 整除,再看 suffix(1)和 suffix(k+1)的最长公共前缀是否等于 n-k。在询问最长公共前缀的时候,suffix(1)是固定的,所以 RMQ问题没有必要做所有的预处理,只需求出 height 数组中的每一个数到height[rank[1]]之间的最小值即可。

    重复次数最多的连续重复子串:

    在这里插入图片描述


    两个字符串的相关问题

    这类问题的一个常用做法是,先连接这两个字符串,然后求后缀数组和height 数组,再利用 height 数组进行求解。

    最长公共子串:

    将第二个字符串写在第一个字符串后面,中间用一个没有出现过的字符隔开,suffix(sa[i-1])和suffix(sa[i])属于不同的串时的height[i]的最大值就是答案。

    长度不小于 k 的公共子串的个数:

    在这里插入图片描述


    多个字符串的相关问题

    这类问题的一个常用做法是,先将所有的字符串连接起来,然后求后缀数组和 height 数组,再利用 height 数组进行求解。这中间可能需要二分答案。

    不小于 k 个字符串中的最长子串:

    将 n 个字符串连起来,中间用不相同的且没有出现在字符串中的字符隔开,求后缀数组。然后二分答案,将后缀分成若干组,判断每组的后缀是否出现在不小于 k 个的原串中。

    每个字符串至少出现两次且不重叠的最长子串:

    做法和上题大同小异,也是先将 n 个字符串连起来,中间用不相同的且没有出现在字符串中的字符隔开,求后缀数组。然后二分答案,再将后缀分组。判断的时候,要看是否有一组后缀在每个原来的字符串中至少出现两次,并且在每个原来的字符串中,后缀的起始位置的最大值与最小值之差是否不小于当前答案(判断能否做到不重叠,如果题目中没有不重叠的要求,那么不用做此判断)。

    展开全文
  • 而软件开发过程是一种高密集度脑力劳动,软件开发模式及技术 能适应软件发展需要。致使大量质量低劣软件涌向市场,有花费大量人力、财力, 而在开发过程中就夭折。软件危机主要表现在两个方面: (1) ...
  • 该资料是《Visual C++ 2005入门经典》源代码及课后练习答案 对应书籍资料见: Visual C++ 2005入门经典 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2005 原出版社: Wiley 作者: (美)Ivor Horton...
  • 该资料是《Visual C++ 2010入门经典(第5版)》源代码及课后练习答案 对应书籍资料见: Visual C++ 2010入门经典(第5版) 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2010 原出版社: Wrox 作者: ...
  • 该资料是《Visual C++ 2008入门经典》源代码及课后练习答案 对应书籍资料见: Visual C++ 2008入门经典 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2008 原出版社: Wrox 作者: (美)Ivor Horton ...
  • 1. 都是重复一段代码,为什么我要使用函数(而使用简单拷贝黏贴)呢? 有函数是带参数,而不同参数所返回值会有所不同 降低代码行数 降低维护成本(如需修改,只需要改进def内容即可) 更容易...

    0. 你有听说过 DRY 吗?


    1. 都是重复一段代码,为什么我要使用函数(而不使用简单的拷贝黏贴)呢?

    有的函数是带参数的,而不同的参数所返回的值会有所不同

    可降低代码行数

    可降低维护成本(如需修改,只需要改进def的内容即可)

    更容易阅读
    2. 函数可以有多个参数吗?

    可以,一般三四个皆宜
    3. 创建函数使用什么关键字,要注意什么?

    def myfunction():
    4. 请问这个函数有多少个参数?
    1. def MyFun((x, y), (a, b)):
    2. return x * y - a * b
    复制代码

    2个

     函数的参数需要的是变量, 而这里你试图用“元祖”的形式来传递是不可行的。
    5. 请问调用以下这个函数会打印什么内容?
    1. >>> def hello():
    2. print('Hello World!')
    3. return
    4. print('Welcome To FishC.com!')
    复制代码

    "Hello World!"
    动动手:
    0. 编写一个函数 power() 模拟内建函数 pow() ,即 power(x, y) 为计算并返回 x 的 y 次幂的值。


    1. 编写一个函数,利用欧几里得算法( 脑补链接 )求最大公约数,例如 gcd(x, y) 返回值为参数 x 和参数 y 的最大公约数。


    2. 编写一个将十进制转换为二进制的函数,要求采用“除 2 取余”( 脑补链接 )的方式,结果与调用 bin() 一样返回字符串形式。

    参考:https://baike.baidu.com/item/%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E7%AE%97%E6%B3%95/1647675?fromtitle=%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%B7%E7%AE%97%E6%B3%95&fromid=9002848

    https://baike.baidu.com/item/%E5%8D%81%E8%BF%9B%E5%88%B6%E8%BD%AC%E4%BA%8C%E8%BF%9B%E5%88%B6/393189?fr=aladdin#2

    展开全文
  • 本文档是为那些想学习Bash而又深入人写。 提示:尝试基于本手册交互式讲习班! 节点打包稿件 您可以使用npm安装该手册。 赶紧跑: $ npm install -g bash-handbook 您现在应该可以在命令行上运行bash-...
  • 阅读本书过程,就是把一些以前模糊地知道,但又觉得很难运用理论实实在在地运用到实践中过程。  虽然本书是针对SQL Server这个特定数据库平台来阐述理论和实践,然而,本书所体现思想和方法,完全可以...
  • 翻译不可太拘泥,否则很容易因死守原文语言形式而损害了原文思想内容,好译文应该是形式与内容统一。能够直译尽量不意译。翻译过程应该是先理解后表达。 【具体方法】首先,英文段落首句一般为topicsentence...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类类型转换。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配...
  • 后缀数组练习题若干

    2014-05-22 21:31:18
    POJ 1743 不可重叠最长重复子串 二分答案。 即子串长度,假设为k时。 利用height数组,将排序后后缀分为若干组。 每组内height值都不小于k。 然后只需查看组内是否有满足要求两个不会产生重叠...

    分类: 后缀数组 数据结构 263人阅读 评论(0) 收藏 举报

    POJ 1743    不可重叠最长重复子串

    二分答案。 即子串的长度,假设为k时。

    利用height数组,将排序后的后缀分为若干组。

    每组内的height值都不小于k。

    然后只需查看组内是否有满足要求的两个不会产生重叠的子串即可。

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <algorithm>  
    8. #define MAXN 22222  
    9. #define MAXM 111  
    10. #define INF 1000000000  
    11. using namespace std;  
    12. int r[MAXN];  
    13. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    14. int sa[MAXN]; //index range 1~n value range 0~n-1  
    15. int cmp(int *r, int a, int b, int l)  
    16. {  
    17.     return r[a] == r[b] && r[a + l] == r[b + l];  
    18. }  
    19. void da(int *r, int *sa, int n, int m)  
    20. {  
    21.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    22.     for (i = 0; i < m; i++) ws[i] = 0;  
    23.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    24.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    25.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    26.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    27.     {  
    28.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    29.         for (i = 0; i < n; i++)  
    30.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    31.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    32.         for (i = 0; i < m; i++) ws[i] = 0;  
    33.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    34.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    35.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    36.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    37.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    38.     }  
    39. }  
    40. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    41. int height[MAXN]; //index from 1   (height[1] = 0)  
    42. void calheight(int *r, int *sa, int n)  
    43. {  
    44.     int i, j, k = 0;  
    45.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    46.     for (i = 0; i < n; height[rank[i++]] = k)  
    47.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    48.     return;  
    49. }  
    50. int n, a[MAXN];  
    51. bool check(int mid, int n)  
    52. {  
    53.     int flag = 0;  
    54.     int mx = -1, mi = n;  
    55.     for(int i = 2; i <= n + 1; i++)  
    56.     {  
    57.         if((i == n + 1 && flag) || (height[i] < mid && flag))  
    58.         {  
    59.             flag = 0;  
    60.             mx = max(mx, sa[i - 1]);  
    61.             mi = min(mi, sa[i - 1]);  
    62.             if(mx - mi >= mid) return true;  
    63.             mi = n, mx = -1;  
    64.         }  
    65.         else if(height[i] >= mid)  
    66.         {  
    67.             flag = 1;  
    68.             mx = max(mx, sa[i - 1]);  
    69.             mi = min(mi, sa[i - 1]);  
    70.         }  
    71.     }  
    72.     return false;  
    73. }  
    74. int main()  
    75. {  
    76.     while(scanf("%d", &n) != EOF && n)  
    77.     {  
    78.         for(int i = 0; i < n; i++) scanf("%d", &a[i]);  
    79.         for(int i = 0; i < n - 1; i++) r[i] = a[i + 1] - a[i] + 89;  
    80.         r[--n] = 0;  
    81.         da(r, sa, n + 1, 200);  
    82.         calheight(r, sa, n);  
    83.         int low = 4, high = n / 2, ans = 0;  
    84.         while(low <= high)  
    85.         {  
    86.             int mid = (low + high) >> 1;  
    87.             if(check(mid, n))  
    88.             {  
    89.                 low = mid + 1;  
    90.                 ans = max(ans, mid);  
    91.             }  
    92.             else high = mid - 1;  
    93.         }  
    94.         if(ans < 4) printf("0\n");  
    95.         else printf("%d\n", ans + 1);  
    96.     }  
    97.     return 0;  
    98. }  


    POJ 3261 可重叠的出现K次的最长重复子串

    还是二分子串长度。 后缀分为若干组,然后判断是否有一个组的size不小于k

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <algorithm>  
    8. #define MAXN 22222  
    9. #define MAXM 111  
    10. #define INF 1000000000  
    11. using namespace std;  
    12. int r[MAXN];  
    13. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    14. int sa[MAXN]; //index range 1~n value range 0~n-1  
    15. int cmp(int *r, int a, int b, int l)  
    16. {  
    17.     return r[a] == r[b] && r[a + l] == r[b + l];  
    18. }  
    19. void da(int *r, int *sa, int n, int m)  
    20. {  
    21.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    22.     for (i = 0; i < m; i++) ws[i] = 0;  
    23.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    24.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    25.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    26.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    27.     {  
    28.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    29.         for (i = 0; i < n; i++)  
    30.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    31.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    32.         for (i = 0; i < m; i++) ws[i] = 0;  
    33.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    34.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    35.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    36.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    37.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    38.     }  
    39. }  
    40. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    41. int height[MAXN]; //index from 1   (height[1] = 0)  
    42. void calheight(int *r, int *sa, int n)  
    43. {  
    44.     int i, j, k = 0;  
    45.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    46.     for (i = 0; i < n; height[rank[i++]] = k)  
    47.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    48.     return;  
    49. }  
    50. int n, k;  
    51. bool check(int mid)  
    52. {  
    53.     int cnt = 1;  
    54.     for(int i = 2; i <= n; i++)  
    55.     {  
    56.         if(height[i] < mid) cnt = 1;  
    57.         else cnt++;  
    58.         if(cnt >= k) return 1;  
    59.     }  
    60.     return 0;  
    61. }  
    62. int main()  
    63. {  
    64.     int m = 0;  
    65.     scanf("%d%d", &n, &k);  
    66.     for(int i = 0; i < n; i++)  
    67.     {  
    68.         scanf("%d", &r[i]);  
    69.         r[i]++;  
    70.         m = max(r[i], m);  
    71.     }  
    72.     r[n] = 0;  
    73.     da(r, sa, n + 1, m + 1);  
    74.     calheight(r, sa, n);  
    75.     int low = 1, high = n;  
    76.     int ans = 0;  
    77.     while(low <= high)  
    78.     {  
    79.         int mid = (low + high) >> 1;  
    80.         if(check(mid))  
    81.         {  
    82.             ans = max(ans, mid);  
    83.             low = mid + 1;  
    84.         }  
    85.         else high = mid - 1;  
    86.     }  
    87.     printf("%d\n", ans);  
    88.     return 0;  
    89. }  




    SPOJ SUBST1 求一个串中不同子串的个数

    每个子串都是某个后缀的前缀

    对于一个后缀。 它将产生n - sa[k]个前缀

    但是有height[k]个前缀是跟前一个字符串的前缀相同。

    故每个后缀的贡献是n - sa[k] - height[k]

    求和即可

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <algorithm>  
    8. #define MAXN 55555  
    9. #define MAXM 111  
    10. #define INF 1000000000  
    11. using namespace std;  
    12. int r[MAXN];  
    13. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    14. int sa[MAXN]; //index range 1~n value range 0~n-1  
    15. int cmp(int *r, int a, int b, int l)  
    16. {  
    17.     return r[a] == r[b] && r[a + l] == r[b + l];  
    18. }  
    19. void da(int *r, int *sa, int n, int m)  
    20. {  
    21.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    22.     for (i = 0; i < m; i++) ws[i] = 0;  
    23.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    24.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    25.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    26.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    27.     {  
    28.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    29.         for (i = 0; i < n; i++)  
    30.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    31.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    32.         for (i = 0; i < m; i++) ws[i] = 0;  
    33.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    34.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    35.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    36.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    37.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    38.     }  
    39. }  
    40. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    41. int height[MAXN]; //index from 1   (height[1] = 0)  
    42. void calheight(int *r, int *sa, int n)  
    43. {  
    44.     int i, j, k = 0;  
    45.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    46.     for (i = 0; i < n; height[rank[i++]] = k)  
    47.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    48.     return;  
    49. }  
    50. char s[MAXN];  
    51. int main()  
    52. {  
    53.     int T;  
    54.     scanf("%d", &T);  
    55.     while(T--)  
    56.     {  
    57.         scanf("%s", s);  
    58.         int n = strlen(s);  
    59.         int m = 0;  
    60.         for(int i = 0; i < n; i++)  
    61.         {  
    62.             r[i] = (int)s[i];  
    63.             m = max(m, r[i]);  
    64.         }  
    65.         r[n] = 0;  
    66.         da(r, sa, n + 1, m + 1);  
    67.         calheight(r, sa, n);  
    68.         long long ans = 0;  
    69.         for(int i = 1; i <= n; i++) ans += n - sa[i] - height[i];  
    70.         printf("%lld\n", ans);  
    71.     }  
    72.     return 0;  
    73. }  


    URAL 1297  求最长回文串

    假设原串为S,将原串倒置后是T。

    建立一个新串S+“~”+T

    然后对新串做后缀数组。

    然后我们枚举的是回文串的中心。

    假设中心的位置为i。

    有两种情况

    回文为奇数

    那么求lcp(i, n - i - 1)

    回文为偶数那么求lcp(i, n - i)

    然后更新最优解即可

    用手画一画就知道是什么意思了。

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <algorithm>  
    8. #define MAXN 111111  
    9. #define MAXM 111  
    10. #define INF 1000000000  
    11. using namespace std;  
    12. int r[MAXN];  
    13. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    14. int sa[MAXN]; //index range 1~n value range 0~n-1  
    15. int cmp(int *r, int a, int b, int l)  
    16. {  
    17.     return r[a] == r[b] && r[a + l] == r[b + l];  
    18. }  
    19. void da(int *r, int *sa, int n, int m)  
    20. {  
    21.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    22.     for (i = 0; i < m; i++) ws[i] = 0;  
    23.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    24.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    25.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    26.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    27.     {  
    28.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    29.         for (i = 0; i < n; i++)  
    30.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    31.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    32.         for (i = 0; i < m; i++) ws[i] = 0;  
    33.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    34.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    35.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    36.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    37.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    38.     }  
    39. }  
    40. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    41. int height[MAXN]; //index from 1   (height[1] = 0)  
    42. void calheight(int *r, int *sa, int n)  
    43. {  
    44.     int i, j, k = 0;  
    45.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    46.     for (i = 0; i < n; height[rank[i++]] = k)  
    47.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    48.     return;  
    49. }  
    50. int Log[MAXN];  
    51. int mi[MAXN][20];  
    52. void rmqinit(int n)  
    53. {  
    54.     for(int i = 1; i <= n; i++) mi[i][0] = height[i];  
    55.     int m = Log[n];  
    56.     for(int i = 1; i <= m; i++)  
    57.         for(int j = 1; j <= n; j++)  
    58.         {  
    59.             mi[j][i] = mi[j][i - 1];  
    60.             if(j + (1 << (i - 1)) <= n) mi[j][i] = min(mi[j][i], mi[j + (1 << (i - 1))][i - 1]);  
    61.         }  
    62. }  
    63. int lcp(int a, int b)  
    64. {  
    65.     a = rank[a];    b = rank[b];  
    66.     if(a > b) swap(a,b);  
    67.     a ++;  
    68.     int t = Log[b - a + 1];  
    69.     return min(mi[a][t] , mi[b - (1<<t) + 1][t]);  
    70. }  
    71. char s[MAXN * 2];  
    72. int main()  
    73. {  
    74.     Log[1] = 0;  
    75.     for(int i = 2; i < MAXN; i++) Log[i] = Log[i >> 1] + 1;  
    76.     while(scanf("%s", s) != EOF)  
    77.     {  
    78.         int len = strlen(s);  
    79.         for(int i = 0; i < len; i++) r[i] = (int)s[i];  
    80.         r[len] = 128;  
    81.         for(int i = 0; i < len; i++) r[len + 1 + i] = (int)s[len - 1 - i];  
    82.         int n = 2 * len + 1;  
    83.         r[n] = 0;  
    84.         da(r, sa, n + 1, 130);  
    85.         calheight(r, sa, n);  
    86.         rmqinit(n);  
    87.         int ans = 0;  
    88.         int pos;  
    89.         for(int i = 0; i < len; i++)  
    90.         {  
    91.             int tmp = lcp(i, n - i - 1); //奇数  
    92.             if(tmp * 2 - 1 > ans)  
    93.             {  
    94.                 ans= tmp * 2 - 1;  
    95.                 pos = i - tmp + 1;  
    96.             }  
    97.             tmp = lcp(i, n - i); //偶数  
    98.             if(tmp * 2 > ans)  
    99.             {  
    100.                 ans = tmp * 2;  
    101.                 pos = i - tmp;  
    102.             }  
    103.         }  
    104.         for(int i = 0; i < ans; i++) putchar(s[pos + i]);  
    105.         puts("");  
    106.     }  
    107.     return 0;  
    108. }  


    POJ 2406  

    给定一个字符串S,已知该串是由某串重复K次 连接得到的。

    求最大的k

    这题的话。 貌似POJ上暴力跑的很快。

    用后缀数组需要的求是枚举子串的长度。

    假设长度为len, 那么检查lcp(0, len)是否等于n - len即可

    倍增在这里被卡掉了

    用的DC3


    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <cmath>  
    8. #include <algorithm>  
    9. #define MAXN 1111111  
    10. #define MAXM 111  
    11. #define INF 1000000000  
    12. #define F(x) ((x)/3+((x)%3==1?0:tb))  
    13. #define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)  
    14. using namespace std;  
    15. int wa[MAXN] , wb[MAXN] , wv[MAXN] , tmp[MAXN];  
    16. int c0(int *r, int a, int b){  
    17.     return r[a] == r[b] && r[a + 1] == r[b + 1] && r[a + 2] == r[b + 2];  
    18. }  
    19. int c12(int k, int *r, int a, int b){  
    20.     if (k == 2)  
    21.     return r[a] < r[b] || r[a] == r[b] && c12(1, r, a + 1, b + 1);  
    22.     else return r[a] < r[b] || r[a] == r[b] && wv[a + 1] < wv[b + 1];  
    23. }  
    24. void sort(int *r, int *a, int *b, int n, int m)  
    25. {  
    26.     int i;  
    27.     for (i = 0; i < n; i++) wv[i] = r[a[i]];  
    28.     for (i = 0; i < m; i++) tmp[i] = 0;  
    29.     for (i = 0; i < n; i++) tmp[wv[i]]++;  
    30.     for (i = 1; i < m; i++) tmp[i] += tmp[i-1];  
    31.     for (i = n-1; i >= 0; i--) b[--tmp[wv[i]]] = a[i];  
    32. }  
    33. void dc3(int *r, int *sa, int n, int m)  
    34. {  
    35.     int i, j, *rn = r + n;  
    36.     int *san = sa + n, ta = 0, tb = (n + 1) / 3, tbc = 0, p;  
    37.     r[n] = r[n + 1] = 0;  
    38.     for (i = 0; i < n; i++) if (i % 3 != 0) wa[tbc++] = i;  
    39.     sort(r + 2, wa, wb, tbc, m);  
    40.     sort(r + 1, wb, wa, tbc, m);  
    41.     sort(r, wa, wb, tbc, m);  
    42.     for (p = 1, rn[F(wb[0])] = 0, i = 1; i < tbc; i++)  
    43.         rn[F(wb[i])] = c0(r, wb[i-1], wb[i]) ? p-1 : p++;  
    44.     if (p < tbc) dc3(rn, san, tbc, p);  
    45.     else for (i = 0; i < tbc; i++) san[rn[i]] = i;  
    46.     for (i = 0; i < tbc; i++) if (san[i] < tb) wb[ta++] = san[i] * 3;  
    47.     if (n % 3 == 1) wb[ta++] = n-1;  
    48.     sort(r, wb, wa, ta, m);  
    49.     for (i = 0; i < tbc; i++) wv[wb[i] = G(san[i])] = i;  
    50.     for (i = 0, j = 0, p = 0; i < ta && j < tbc; p++)  
    51.         sa[p] = c12(wb[j] % 3, r, wa[i], wb[j]) ? wa[i++] : wb[j++];  
    52.     for (; i < ta; p++) sa[p] = wa[i++];  
    53.     for (; j < tbc; p++) sa[p] = wb[j++];  
    54. }  
    55. void da(int str[], int sa[], int rank[], int height[], int n, int m)  
    56. {  
    57. //       for (int i = n; i < n * 3; i++)  
    58. //        str[i] = 0;  
    59.     dc3 (str , sa , n + 1 , m);  
    60.     int i, j, k;  
    61.     for (i = 0; i < n; i++){  
    62.         sa[i] = sa[i + 1];  
    63.         rank[sa[i]] = i;  
    64.     }  
    65.     for (i = 0, j = 0, k = 0; i < n; height[rank[i ++]] = k)  
    66.         if (rank[i] > 0)  
    67.             for (k ? k--: 0 , j = sa[rank[i]-1];  
    68.             i + k < n && j + k < n && str[i + k] == str[j + k];  
    69.             k++);  
    70. }  
    71. int lcp[MAXN];  
    72. int r[MAXN];  
    73. int  sa[MAXN], rank[MAXN] , height[MAXN];  
    74. int n;  
    75. void getlcp()  
    76. {  
    77.     int k = rank[0];  
    78.     lcp[k] = n;  
    79.     for(int i = k; i >= 2; i--)  
    80.         lcp[i - 1] = min(lcp[i], height[i]);  
    81.     for(int i = k + 1; i <= n; i++)  
    82.         lcp[i] = min(lcp[i - 1], height[i]);  
    83. }  
    84. char s[MAXN];  
    85. bool ok(int k)  
    86. {  
    87.     int rk = rank[k];  
    88.     if(lcp[rk] == n - k) return true;  
    89.     return false;  
    90. }  
    91. int main()  
    92. {  
    93.     while(gets(s))  
    94.     {  
    95.         if(s[0] == '.'break;  
    96.         n = strlen(s);  
    97.         for(int i = 0; i <= n; i++) r[i] = s[i];  
    98.         da(r, sa, rank, height, n + 1, 130);  
    99.         getlcp();  
    100.         int tmp = (int)sqrt(n + 0.5);  
    101.         int ans = 0;  
    102.         for(int i = 1; i <= tmp; i++)  
    103.         {  
    104.             if(n % i != 0) continue;  
    105.             if(ok(i)) ans = max(ans, n / i);  
    106.             if(ok(n / i)) ans = max(ans, i);  
    107.         }  
    108.         printf("%d\n", ans);  
    109.     }  
    110.     return 0;  
    111. }  



    POJ 3693


    题目大意就是求重复次数最多的连续重复子串。例如abababc 答案就是ababab  因为ab连续出现的次数最多

    并且题目还要求输出字典序最小的

    比如abababcdcdcd 

    ababab和cdcdcd都符合要求

    但是ababab字典序小


    具体做法参见罗穗骞的论文

    穷举子串的长度L,然后求长度为L的子串最多出现几次

    首先连续出现一次是肯定的,所以只考虑出现两次及以上的情况

    假设在字符串中出现了两次,记这个重复了两次L长度子串的子串为S。

    那么S肯定包含了字符r[0], r[L], r[L*2], r[3 * L]....中的某相邻的两个。

    所以就看r[L*i]和r[L*(i + 1)]往前往后分别匹配到多远,记这个长度为K(具体匹配方式看代码),那么就连续出现了K/L+1次,最后看最大值多少

    注意每次求这个k要分为两种情况,一是公共前缀恰好模L等于0,另一种是模L不等于0

    模L不等于0时还要计算一个值,假如公共前缀%L等于t,就求lcp(i - (L - t), i - (L - t) + L);

    为什么呢,我们画一画就知道了,这样的做法,实际上两个公共前缀往前延伸了几个位置,使得前缀的长度加上延伸的长度是L的倍数

    然后求lcp,会发现,他是有可能比原来的k大的,那么连续出现的次数也有可能改变。所以这种情况不能遗漏

    这里用到了lcp,既求任意两个后缀的最长公共前缀,使用RMQ实现。

    最后输出的时候,由于要按字典序输出,就枚举sa数组

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <vector>  
    5. #include <set>  
    6. #include <queue>  
    7. #include <cmath>  
    8. #include <algorithm>  
    9. #define MAXN 1111111  
    10. #define MAXM 111  
    11. #define INF 1000000000  
    12. using namespace std;  
    13. int r[MAXN];  
    14. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    15. int sa[MAXN]; //index range 1~n value range 0~n-1  
    16. int cmp(int *r, int a, int b, int l)  
    17. {  
    18.     return r[a] == r[b] && r[a + l] == r[b + l];  
    19. }  
    20. void da(int *r, int *sa, int n, int m)  
    21. {  
    22.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    23.     for (i = 0; i < m; i++) ws[i] = 0;  
    24.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    25.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    26.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    27.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    28.     {  
    29.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    30.         for (i = 0; i < n; i++)  
    31.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    32.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    33.         for (i = 0; i < m; i++) ws[i] = 0;  
    34.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    35.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    36.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    37.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    38.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    39.     }  
    40. }  
    41. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    42. int height[MAXN]; //index from 1   (height[1] = 0)  
    43. void calheight(int *r, int *sa, int n)  
    44. {  
    45.     int i, j, k = 0;  
    46.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    47.     for (i = 0; i < n; height[rank[i++]] = k)  
    48.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    49.     return;  
    50. }  
    51. int Log[MAXN];  
    52. int mi[MAXN][20];  
    53. void rmqinit(int n)  
    54. {  
    55.     for(int i = 1; i <= n; i++) mi[i][0] = height[i];  
    56.     int m = Log[n];  
    57.     for(int i = 1; i <= m; i++)  
    58.         for(int j = 1; j <= n; j++)  
    59.         {  
    60.             mi[j][i] = mi[j][i - 1];  
    61.             if(j + (1 << (i - 1)) <= n) mi[j][i] = min(mi[j][i], mi[j + (1 << (i - 1))][i - 1]);  
    62.         }  
    63. }  
    64. int lcp(int a, int b)  
    65. {  
    66.     a = rank[a];    b = rank[b];  
    67.     if(a > b) swap(a,b);  
    68.     a ++;  
    69.     int t = Log[b - a + 1];  
    70.     return min(mi[a][t] , mi[b - (1<<t) + 1][t]);  
    71. }  
    72. char s[MAXN];  
    73. int ans[MAXN];  
    74. int main()  
    75. {  
    76.     int cas = 0;  
    77.     Log[1] = 0;  
    78.     for(int i = 2; i < MAXN; i++) Log[i] = Log[i >> 1] + 1;  
    79.     while(scanf("%s", s) != EOF)  
    80.     {  
    81.         if(s[0] == '#'break;  
    82.         int n = strlen(s);  
    83.         for(int i = 0; i < n; i++) r[i] = s[i];  
    84.         r[n] = 0;  
    85.         da(r, sa, n + 1, 130);  
    86.         calheight(r, sa, n);  
    87.         rmqinit(n);  
    88.         int cnt = 0;  
    89.         int mx = -1;  
    90.         int l;  
    91.         for(l = 1; l < n; l++)  
    92.         {  
    93.             for(int i = 0; i + l < n; i += l)  
    94.             {  
    95.                 int k = lcp(i, i + l);  
    96.                 int p = k / l + 1;  
    97.                 int t = l - k % l;  
    98.                 t = i - t;  
    99.                 if(t >= 0 && k % l)  
    100.                 {  
    101.                     int tk = lcp(t, t + l);  
    102.                     if(tk / l + 1 > p) p = tk / l + 1;  
    103.                 }  
    104.                 if(p > mx)  
    105.                 {  
    106.                     cnt = 0;  
    107.                     mx = p;  
    108.                     ans[cnt++] = l;  
    109.                 }  
    110.                 if(p == mx) ans[cnt++] = l;  
    111.             }  
    112.         }  
    113.         int pos = 0;  
    114.         int flag = 0;  
    115.         for(int i = 1; i <= n && !flag; i++)  
    116.         {  
    117.             for(int j = 0; j < cnt; j++)  
    118.             {  
    119.                 int k = ans[j];  
    120.                 if(lcp(sa[i], sa[i] + k) >= (mx - 1) * k)  
    121.                 {  
    122.                     pos = sa[i];  
    123.                     l = mx * k;  
    124.                     flag = 1;  
    125.                     break;  
    126.                 }  
    127.             }  
    128.         }  
    129.         printf("Case %d: ", ++cas);  
    130.         for(int i = 0; i < l; i++) printf("%c", s[pos + i]);  
    131.         printf("\n");  
    132.     }  
    133.     return 0;  
    134. }  

    SPOJ REPEATS

    这题跟前边的一题一样。

    POJ 2774

    最长公共子串。

    非常简单

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #define MAXN 1000005  
    8. using namespace std;  
    9. int r[MAXN];  
    10. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    11. int sa[MAXN]; //index range 1~n value range 0~n-1  
    12. int cmp(int *r, int a, int b, int l)  
    13. {  
    14.     return r[a] == r[b] && r[a + l] == r[b + l];  
    15. }  
    16. void da(int *r, int *sa, int n, int m)  
    17. {  
    18.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    19.     for (i = 0; i < m; i++) ws[i] = 0;  
    20.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    21.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    22.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    23.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    24.     {  
    25.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    26.         for (i = 0; i < n; i++)  
    27.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    28.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    29.         for (i = 0; i < m; i++) ws[i] = 0;  
    30.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    31.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    32.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    33.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    34.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    35.     }  
    36. }  
    37. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    38. int height[MAXN]; //index from 1   (height[1] = 0)  
    39. void calheight(int *r, int *sa, int n)  
    40. {  
    41.     int i, j, k = 0;  
    42.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    43.     for (i = 0; i < n; height[rank[i++]] = k)  
    44.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    45.     return;  
    46. }  
    47. char s1[MAXN], s2[MAXN];  
    48. int main()  
    49. {  
    50.     gets(s1);  
    51.     gets(s2);  
    52.   
    53.     int len = strlen(s1);  
    54.     strcat(s1, "$");  
    55.     strcat(s1, s2);  
    56.     int n = strlen(s1), m = 0;  
    57.     for(int i = 0; i < n; i++)  
    58.     {  
    59.         m = max(m, (int)s1[i]);  
    60.         r[i] = s1[i];  
    61.     }  
    62.     r[n] = 0;  
    63.     da(r, sa, n + 1, m + 1);  
    64.     calheight(r, sa, n);  
    65.     int res = 0;  
    66.     for(int i = 1; i <= n; i++)  
    67.         if((sa[i - 1] < len && sa[i] >= len) || (sa[i - 1] >= len && sa[i] < len)) res = max(res, height[i]);  
    68.     printf("%d\n", res);  
    69.   
    70.     return 0;  
    71. }  


    URAL 1517

    还是最长公共子串

    POJ 3415

    比较厉害的一题

    要用到单调栈

    我抄了爱酱的代码

    求出长度不小于k的公共子串个数

    计算A的某个后缀与B的某个后缀的最长公共前缀长度,如果长度L大于k,则加上L-k+1组。
    将两个字符串连接起来,中间用一个没有出现的字符分开

    然后通过height数组分组,某个组内的height都是大于等于k的,也就是任意两个后缀的最长公共前缀都至少为k。
    扫描一遍,遇到一个B的后缀就与之前的A后缀进行统计,求出所有的满足的组数。但是这样的做法便是n^2的。
    可以发现两个后缀的最长公共前缀为这一段的height值的最小值。
    可以通过一个单调栈来维护一下,当前要入栈元素如果小于栈底元素,说明之后加入的B后缀与栈底的最长公共前缀是小于等于入栈的。这样就保证了单调栈内的height值是绝对递增的,逐渐合并
    然后扫描两遍即可

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #define MAXN 200005  
    8. using namespace std;  
    9. int r[MAXN];  
    10. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    11. int sa[MAXN]; //index range 1~n value range 0~n-1  
    12. int cmp(int *r, int a, int b, int l)  
    13. {  
    14.     return r[a] == r[b] && r[a + l] == r[b + l];  
    15. }  
    16. void da(int *r, int *sa, int n, int m)  
    17. {  
    18.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    19.     for (i = 0; i < m; i++) ws[i] = 0;  
    20.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    21.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    22.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    23.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    24.     {  
    25.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    26.         for (i = 0; i < n; i++)  
    27.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    28.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    29.         for (i = 0; i < m; i++) ws[i] = 0;  
    30.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    31.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    32.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    33.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    34.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    35.     }  
    36. }  
    37. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    38. int height[MAXN]; //index from 1   (height[1] = 0)  
    39. void calheight(int *r, int *sa, int n)  
    40. {  
    41.     int i, j, k = 0;  
    42.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    43.     for (i = 0; i < n; height[rank[i++]] = k)  
    44.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    45.     return;  
    46. }  
    47. char s1[MAXN], s2[MAXN];  
    48. int k;  
    49. int st[MAXN][2];  
    50. int main()  
    51. {  
    52.     while(scanf("%d", &k) != EOF && k)  
    53.     {  
    54.         getchar();  
    55.         gets(s1);  
    56.         gets(s2);  
    57.         int len = strlen(s1);  
    58.         strcat(s1, "$");  
    59.         strcat(s1, s2);  
    60.         int n = strlen(s1), m = 0;  
    61.         for(int i = 0; i < n; i++)  
    62.         {  
    63.             m = max(m, (int)s1[i]);  
    64.             r[i] = s1[i];  
    65.         }  
    66.         r[n] = 0;  
    67.         da(r, sa, n + 1, m + 1);  
    68.         calheight(r, sa, n);  
    69.         int top = 0;  
    70.         long long tot = 0;  
    71.         long long sum = 0;  
    72.         for(int i = 2; i <= n; i++)  
    73.         {  
    74.             if(height[i] < k) top = tot = 0;  
    75.             else  
    76.             {  
    77.                 int cnt = 0;  
    78.                 if(sa[i - 1] < len) cnt++, tot += height[i] - k + 1;  
    79.                 while(top && height[i] <= st[top][0])  
    80.                 {  
    81.                     tot -= st[top][1] * (st[top][0] - height[i]);  
    82.                     cnt += st[top][1];  
    83.                     top--;  
    84.                 }  
    85.                 st[++top][0] = height[i];  
    86.                 st[top][1] = cnt;  
    87.                 if(sa[i] > len) sum += tot;  
    88.             }  
    89.         }  
    90.         top = tot = 0;  
    91.         for(int i = 2; i <= n; i++)  
    92.         {  
    93.             if(height[i] < k) top = tot = 0;  
    94.             else  
    95.             {  
    96.                 int cnt = 0;  
    97.                 if(sa[i - 1] > len) cnt++, tot += height[i] - k + 1;  
    98.                 while(top && height[i] <= st[top][0])  
    99.                 {  
    100.                     tot -= st[top][1] * (st[top][0] - height[i]);  
    101.                     cnt += st[top][1];  
    102.                     top--;  
    103.                 }  
    104.                 st[++top][0] = height[i];  
    105.                 st[top][1] = cnt;  
    106.                 if(sa[i] < len) sum += tot;  
    107.             }  
    108.         }  
    109.         printf("%I64d\n", sum);  
    110.     }  
    111.     return 0;  
    112. }  


    POJ 3294

    求多个字符串的最长公共子串。

    如有多个,按字典序输出

    还是用若干个互不相同且没出现的字符将这些字符串给衔接起来

    然后二分进行分组。

    看组内是不是所有字符串都有后缀在里面

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 211111  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    45. int height[MAXN]; //index from 1   (height[1] = 0)  
    46. void calheight(int *r, int *sa, int n)  
    47. {  
    48.     int i, j, k = 0;  
    49.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    50.     for (i = 0; i < n; height[rank[i++]] = k)  
    51.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    52.     return;  
    53. }  
    54. int m;  
    55. char s[MAXN];  
    56. char ts[1111];  
    57. int id[MAXN], n;  
    58. int vis[1111];  
    59. bool check(int mid)  
    60. {  
    61.     int flag = 0, cnt = 0;  
    62.     memset(vis, -1, sizeof(vis));  
    63.     for(int i = 1; i <= n; i++)  
    64.     {  
    65.         if(id[sa[i]] == -1)  
    66.         {  
    67.             flag++;  
    68.             cnt = 1;  
    69.             continue;  
    70.         }  
    71.         if(height[i] < mid)  
    72.         {  
    73.             cnt = 1;  
    74.             vis[id[sa[i]]] = ++flag;  
    75.         }  
    76.         else  
    77.         {  
    78.             if(vis[id[sa[i]]] != flag) cnt++;  
    79.             vis[id[sa[i]]] = flag;  
    80.         }  
    81.         if(cnt > m / 2) return true;  
    82.     }  
    83.     return false;  
    84. }  
    85. void getans(int x)  
    86. {  
    87.     int flag = 0, cnt = 0, bg, ok = 0;  
    88.     memset(vis, -1, sizeof(vis));  
    89.     for(int i = 1; i <= n; i++)  
    90.     {  
    91.         if(id[sa[i]] == -1)  
    92.         {  
    93.             flag++;  
    94.             cnt = 1;  
    95.             continue;  
    96.         }  
    97.         if(height[i] < x)  
    98.         {  
    99.             cnt = 1;  
    100.             vis[id[sa[i]]] = ++flag;  
    101.             ok = 0;  
    102.             bg = sa[i];  
    103.         }  
    104.         else  
    105.         {  
    106.             if(vis[id[sa[i]]] != flag) cnt++;  
    107.             vis[id[sa[i]]] = flag;  
    108.         }  
    109.         if(cnt > m / 2 && !ok)  
    110.         {  
    111.             ok = 1;  
    112.             for(int j = 0; j < x; j++) putchar(s[bg + j]);  
    113.             puts("");  
    114.         }  
    115.     }  
    116. }  
    117. int main()  
    118. {  
    119.     int cas = 0;  
    120.     while(scanf("%d", &m) != EOF && m)  
    121.     {  
    122.         if(cas++) puts("");  
    123.         scanf("%s", s);  
    124.         if(m == 1)  
    125.         {  
    126.             puts(s);  
    127.             continue;  
    128.         }  
    129.         int now = 130;  
    130.         for(int i = 1; i < m; i++)  
    131.         {  
    132.             scanf("%s", ts);  
    133.             strcat(s, "$");  
    134.             strcat(s, ts);  
    135.         }  
    136.         n = strlen(s);  
    137.         int cnt = 1;  
    138.         for(int i = 0; i < n; i++)  
    139.         {  
    140.             id[i] = cnt;  
    141.             r[i] = s[i];  
    142.             if(s[i] == '$') id[i] = -1, cnt++, r[i] = 130 + cnt;  
    143.         }  
    144.         r[n] = 0;  
    145.   
    146.         da(r, sa, n + 1, 250);  
    147.         calheight(r, sa, n);  
    148.         int low = 0, high = n;  
    149.         int ans = 0;  
    150.         while(low <= high)  
    151.         {  
    152.             int mid = (low + high) >> 1;  
    153.             if(check(mid))  
    154.             {  
    155.                 ans = max(ans, mid);  
    156.                 low = mid + 1;  
    157.             }  
    158.             else high = mid - 1;  
    159.         }  
    160.         if(ans)  
    161.             getans(ans);  
    162.         else puts("?");  
    163.     }  
    164.     return 0;  
    165. }  


    SPOJ PHRASES

    求最长公共子串。

    且该子串要在每个字符串中不重叠的出现至少两次

    二分分组。

    然后看每组内

    记录一个位置的最大值,一个位置的最小值

    观察差值即可


    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 111111  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    45. int height[MAXN]; //index from 1   (height[1] = 0)  
    46. void calheight(int *r, int *sa, int n)  
    47. {  
    48.     int i, j, k = 0;  
    49.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    50.     for (i = 0; i < n; height[rank[i++]] = k)  
    51.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    52.     return;  
    53. }  
    54. int n, k;  
    55. char s[11111];  
    56. int id[MAXN];  
    57. int mi[111], mx[111];  
    58. bool check(int mid)  
    59. {  
    60.     for(int i = 1; i <= k; i++) mi[i] = INF, mx[i] = 0;  
    61.     for(int i = 1; i <= n; i++)  
    62.     {  
    63.         int t = id[sa[i]];  
    64.         if(height[i] < mid)  
    65.         {  
    66.             for(int j = 1; j <= k; j++) mi[j] = INF, mx[j] = 0;  
    67.             mx[t] = sa[i];  
    68.             mi[t] = sa[i];  
    69.         }  
    70.         else  
    71.         {  
    72.             int flag = 1;  
    73.             mx[t] = max(mx[t], sa[i]);  
    74.             mi[t] = min(mi[t], sa[i]);  
    75.             for(int j = 1; j <= k; j++)  
    76.                 if(mx[j] - mi[j] < mid)  
    77.                     flag = 0;  
    78.             if(flag) return true;  
    79.         }  
    80.     }  
    81.     return false;  
    82. }  
    83. int main()  
    84. {  
    85.     int T;  
    86.     scanf("%d", &T);  
    87.     while(T--)  
    88.     {  
    89.         scanf("%d", &k);  
    90.         n = 0;  
    91.         int op = 130;  
    92.         memset(id, 0, sizeof(id));  
    93.         for(int i = 1; i <= k; i++)  
    94.         {  
    95.             scanf("%s", s);  
    96.             int len = strlen(s);  
    97.             for(int j = 0; j < len; j++)  
    98.             {  
    99.                 r[n] = s[j];  
    100.                 id[n++] = i;  
    101.             }  
    102.             r[n++] = op++;  
    103.         }  
    104.         r[--n] = 0;  
    105.         da(r, sa, n + 1, 150);  
    106.         calheight(r, sa, n);  
    107.         int low = 0, high = 10000, ans = 0;  
    108.         while(low <= high)  
    109.         {  
    110.             int mid = (low + high) >> 1;  
    111.             if(check(mid))  
    112.             {  
    113.                 ans = max(ans, mid);  
    114.                 low = mid + 1;  
    115.             }  
    116.             else high = mid - 1;  
    117.         }  
    118.         printf("%d\n", ans);  
    119.     }  
    120.     return 0;  
    121. }  



    POJ 3581

    比较神的一题

    给出一个序列

    然后把这个序列拆成三部分

    将每部分翻转后拼起来。

    使得字典序最小

    首先。我们将整个序列先翻转

    然后找到排名第一的后缀,并且位置要>=2,因为不能使其他两个部分没数可用了,这个就是第一部分了

    第二部分怎么搞呢。

    将剩余的序列,复制一遍,添加到这个序列后面。

    求一遍后缀数组。

    最小的,并且位置>=1,不超过现在序列一般位置的即为第二部分的开始位置。

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 211111  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44.   
    45. int a[MAXN], b[MAXN];  
    46. int n, m;  
    47.   
    48. int main()  
    49. {  
    50.     scanf("%d", &n);  
    51.     for(int i = 0; i < n; i++)  
    52.     {  
    53.         scanf("%d", &a[n - 1 - i]);  
    54.         b[n - 1 - i] = a[n - 1 - i];  
    55.     }  
    56.     sort(b, b + n);  
    57.     int cnt = unique(b, b + n) - b;  
    58.     for(int i = 0; i < n; i++)  
    59.     {  
    60.         int pos = lower_bound(b, b + cnt, a[i]) - b + 1;  
    61.         r[i] = pos;  
    62.     }  
    63.     r[n] = 0;  
    64.     m = n + 1;  
    65.     da(r, sa, n + 1, m);  
    66.     int pos;  
    67.     for(int i = 1; i <= n; i++)  
    68.         if(sa[i] >= 2)  
    69.         {  
    70.             pos = sa[i];  
    71.             break;  
    72.         }  
    73.     for(int i = pos; i < n; i++) printf("%d\n", b[r[i] - 1]);  
    74.     n = pos;  
    75.     for(int i = 0; i < pos; i++) r[n + i] = r[i];  
    76.     n = n + n;  
    77.     r[n] = 0;  
    78.     da(r, sa, n + 1, m);  
    79.     for(int i = 1; i <= n; i++)  
    80.         if(sa[i] >= 1 && sa[i] < n / 2)  
    81.         {  
    82.             pos = sa[i];  
    83.             break;  
    84.         }  
    85.     for(int j = 0; j < n / 2; j++) printf("%d\n", b[r[j + pos] - 1]);  
    86.     return 0;  
    87. }  


    POJ 3623

    将字符串翻转后连接到原来的字符串后

    中间用个没出现的字符隔开

    然后我们拿的时候就要看他们的rank了

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 111111  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    45. int height[MAXN]; //index from 1   (height[1] = 0)  
    46. void calheight(int *r, int *sa, int n)  
    47. {  
    48.     int i, j, k = 0;  
    49.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    50.     for (i = 0; i < n; height[rank[i++]] = k)  
    51.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    52.     return;  
    53. }  
    54. char s[MAXN];  
    55. int n, m;  
    56. int main()  
    57. {  
    58.     scanf("%d", &n);  
    59.     m = n;  
    60.     for(int i = 0; i < n; i++) scanf("%s", &s[i]);  
    61.     for(int i = 0; i < n; i++) r[i] = s[i];  
    62.     r[n] = '$';  
    63.     for(int i = n - 1; i >= 0; i--) r[++n] = s[i];  
    64.     r[++n] = 0;  
    65.     da(r, sa, n + 1, 130);  
    66.     calheight(r, sa, n);  
    67.     int low = 0, high = m - 1, cnt = 0;  
    68.     for(int i = 0; i < m; i++)  
    69.     {  
    70.         int ra = rank[low], rb = rank[2 * m - high];  
    71.         if(ra < rb)  
    72.         {  
    73.             putchar(s[low]);  
    74.             low++;  
    75.         }  
    76.         else  
    77.         {  
    78.             putchar(s[high]);  
    79.             high--;  
    80.         }  
    81.         cnt++;  
    82.         if(cnt % 80 == 0) putchar('\n');  
    83.     }  
    84.   
    85.     return 0;  
    86. }  


    POJ 3450

    所有字符串的最长公共子串。

    二分分组搞一下即可

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 888888  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    45. int height[MAXN]; //index from 1   (height[1] = 0)  
    46. void calheight(int *r, int *sa, int n)  
    47. {  
    48.     int i, j, k = 0;  
    49.     for (i = 1; i <= n; ++i) rank[sa[i]] = i;  
    50.     for (i = 0; i < n; height[rank[i++]] = k)  
    51.         for (k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; ++k);  
    52.     return;  
    53. }  
    54. char s[2222];  
    55. int m, n;  
    56. int id[MAXN];  
    57. int vis[4005];  
    58. char res[2222];  
    59. bool check(int mid)  
    60. {  
    61.     int flag = 0, tot = 1, bg;  
    62.     memset(vis, -1, sizeof(vis));  
    63.     for(int i = 1; i <= n; i++)  
    64.     {  
    65.         int t = id[sa[i]];  
    66.         if(t == 0)  
    67.         {  
    68.             flag++;  
    69.             tot = 1;  
    70.             continue;  
    71.         }  
    72.         if(height[i] < mid)  
    73.         {  
    74.             vis[t] = ++flag;  
    75.             tot = 1;  
    76.             bg = sa[i];  
    77.         }  
    78.         else  
    79.         {  
    80.             if(vis[t] != flag) tot++;  
    81.             vis[t] = flag;  
    82.         }  
    83.         if(tot >= m)  
    84.         {  
    85.             //printf("%d\n", tot);  
    86.             for(int j = 0; j < mid; j++) res[j] = (char)r[bg + j];  
    87.             res[mid] = '\0';  
    88.             return 1;  
    89.         }  
    90.     }  
    91.     return 0;  
    92. }  
    93. int main()  
    94. {  
    95.     while(scanf("%d", &m) != EOF && m)  
    96.     {  
    97.         int op = 130;  
    98.         n = 0;  
    99.         memset(id, 0, sizeof(id));  
    100.         for(int i = 1; i <= m; i++)  
    101.         {  
    102.             scanf("%s", s);  
    103.             int len = strlen(s);  
    104.             for(int j = 0; j < len; j++)  
    105.             {  
    106.                 r[n] = s[j];  
    107.                 id[n++] = i;  
    108.             }  
    109.             r[n++] = op++;  
    110.         }  
    111.         n--;  
    112.         r[n] = 0;  
    113.         da(r, sa, n + 1, op + 1);  
    114.         calheight(r, sa, n);  
    115.         int low = 0, high = n, ans = 0;  
    116.         while(low <= high)  
    117.         {  
    118.             int mid = (low + high) >> 1;  
    119.             if(check(mid))  
    120.             {  
    121.                 ans = max(ans, mid);  
    122.                 low = mid + 1;  
    123.             }  
    124.             else high = mid - 1;  
    125.         }  
    126.         if(ans) printf("%s\n", res);  
    127.         else puts("IDENTITY LOST");  
    128.     }  
    129.     return 0;  
    130. }  



    POJ 2758

    http://hi.baidu.com/billdu/item/ebfe510f1b2f3fce90571807

    这个讲的很明白。。

    需要注意的就是

    我们平常求lcp的时候默认是所求的两个位置是不一样的。

    但是此题中会求相同位置的lcp

    所以特殊处理一下

    1. #include <iostream>  
    2. #include <cstdio>  
    3. #include <cstring>  
    4. #include <string>  
    5. #include <algorithm>  
    6. #include <cstdlib>  
    7. #include <cmath>  
    8. #include <map>  
    9. #include <sstream>  
    10. #include <queue>  
    11. #include <vector>  
    12. #define MAXN 100001  
    13. #define MAXM 211111  
    14. #define INF 500000001  
    15. using namespace std;  
    16. int r[MAXN];  
    17. int wa[MAXN], wb[MAXN], wv[MAXN], tmp[MAXN];  
    18. int sa[MAXN]; //index range 1~n value range 0~n-1  
    19. int cmp(int *r, int a, int b, int l)  
    20. {  
    21.     return r[a] == r[b] && r[a + l] == r[b + l];  
    22. }  
    23. void da(int *r, int *sa, int n, int m)  
    24. {  
    25.     int i, j, p, *x = wa, *y = wb, *ws = tmp;  
    26.     for (i = 0; i < m; i++) ws[i] = 0;  
    27.     for (i = 0; i < n; i++) ws[x[i] = r[i]]++;  
    28.     for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    29.     for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;  
    30.     for (j = 1, p = 1; p < n; j *= 2, m = p)  
    31.     {  
    32.         for (p = 0, i = n - j; i < n; i++) y[p++] = i;  
    33.         for (i = 0; i < n; i++)  
    34.             if (sa[i] >= j) y[p++] = sa[i] - j;  
    35.         for (i = 0; i < n; i++) wv[i] = x[y[i]];  
    36.         for (i = 0; i < m; i++) ws[i] = 0;  
    37.         for (i = 0; i < n; i++) ws[wv[i]]++;  
    38.         for (i = 1; i < m; i++) ws[i] += ws[i - 1];  
    39.         for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];  
    40.         for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; i++)  
    41.             x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;  
    42.     }  
    43. }  
    44. int rank[MAXN]; //index range 0~n-1 value range 1~n  
    45. int height[MAXN]; //index from 1   (height[1] = 0)  
    46. void calheight(int *r, int *sa, int n)  
    47. {