Common Substrings 【POJ - 3415】【后缀数组+单调栈】

最新推荐文章于 2021-10-20 13:42:10 发布
最新推荐文章于 2021-10-20 13:42:10 发布
阅读量196 收藏 1
点赞数 1
分类专栏： 后缀数组 单调队列/栈 文章标签： 后缀数组 单调栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41730082/article/details/103940120
版权

题目链接

  不会做的时候看了网上的代码，但是发现他们都没有讲过程由来，这里我就大致的讲一下我和队友推出来的解题思路了。

  题目中，给出了一个K和两个字符串，我们现在想要知道的是，在两个字符串中出现长度大于等于K的相等子串这样的匹配对有几个？

  首先，考虑相等子串，确确实实的往后缀数组的LCP上想，也就是往height[]上靠，然后呢，就是求解的办法了，先想想看O(N*K)的解决办法，也就是从K～N的枚举所有的长度，我们来看所有的满足该长度的区间，每个区间对答案的贡献就是：（区间内的串1的个数 * 区间内的串2的个数 * （区间height的最小值 - 区间两边的最大值））。

  再详细一点。

  例如说，我们看到height是{0，1，2，1，2，0}，那么，第一个“1”制造的贡献区间是1～2，第一个“2”制造的贡献区间是2～3，第二个“1”会阻拦第一个“2”的区间，把它限制在里面，所以会使得“2”只能贡献与2～3了，并且它所制造的“相同程度为2”的贡献是2～3中的区间串1个数乘以串2个数。如果说被包围的值是Y的时候，周围是“X，Y，Z”，Y本身的贡献就是，（Y-min(X, Y)） * 区间中串1的个数 * 区间中串2的个数。

  这样的话，我们确确实实可以说是完成了暴力的做法，该想办法优化了，如果我们能吧O(N * K)\approx O(N^2)优化成O(N)，那么，这个问题就可以迎刃而解了。

  想一下，我们上面的{0，1，2，1，2，0}是不是可以确定每个值对应的区间范围，第一个“1”的贡献区间范围是可以跟第二个“1”一块合成成[1, 4]，第一个“2”的区间贡献范围是[2, 3]，第二个“2”的区间贡献范围是[4, 5]，不难发现，其中有单调栈的缩影。

  也就是，我们现在来维护一个单调上升的（升序的）单调栈（栈底小于栈顶）。那么，如果新进来的点比栈顶小的话，那么栈顶的贡献就可以拎出去算了，因为这时候它的区间已经可以求解了。最后，有一个关键点，我们遇到相等的时候，要么就是弹出之前的，放进现在的，要么就是直接更新栈顶的元素信息——这样做的目的是为了如果后来的比它大的元素（在它之后入栈的元素）的左右区间是正确的。

  总结陈词：我们首先就是从维护区间height的角度来展开问题，再来就是对于height性质的拓展，由于他的“区间最小”的性质，我们可以去利用单调栈来降一维来线性时间的解决该问题。

1
INUIS
NISU
ans:6

以上是一组样例

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e5 + 7;
struct SA
{
    int n, m;
    int s[maxN];
    int y[maxN], x[maxN], c[maxN], sa[maxN], rk[maxN], height[maxN];
    inline void get_SA()
    {
        for(int i=1; i<=m; i++) c[i] = 0;   //桶的初始化
        for(int i=1; i<=n; i++) ++c[x[i] = s[i]];
        for(int i=2; i<=m; i++) c[i] += c[i - 1];   //利用差分前缀和的思想知道每个关键字最多是在第几名
        for(int i=n; i>=1; i--) sa[c[x[i]]--] = i;
        for(int k=1; k<=n; k<<=1)
        {
            int num = 0;
            for(int i=n - k + 1; i<=n; i++) y[++num] = i;
            for(int i=1; i<=n; i++) if(sa[i] > k) y[++num] = sa[i] - k; //是否可以作为第二关键字
            for(int i=1; i<=m; i++) c[i] = 0;
            for(int i=1; i<=n; i++) c[x[i]]++;  //因为上一次循环已经求出这次的第一关键字了
            for(int i=2; i<=m; i++) c[i] += c[i - 1];
            for(int i=n; i>=1; i--) //在同一第一关键字下，按第二关键字来排
            {
                sa[c[x[y[i]]]--] = y[i];
                y[i] = 0;
            }
            swap(x, y);
            x[sa[1]] = 1; num = 1;
            for(int i=2; i<=n; i++)
            {
                x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) ? num : ++num;
            }
            if(num == n) break;
            m = num;
        }
    }
    inline void get_height()
    {
        int k = 0;
        for(int i=1; i<=n; i++) rk[sa[i]] = i;
        for(int i=1; i<=n; i++)
        {
            if(rk[i] == 1) continue;    //第一名的height为0
            if(k) k--;  //height[i] >= height[i - 1] - 1
            int j = sa[rk[i] - 1];
            while(j + k <= n && i + k <= n && s[i + k] == s[j + k]) k++;
            height[rk[i]] = k;
        }
    }
    inline void clear()
    {
        n = 0; m = 200;
    }
} sa;
int K, len, N_mid, Stop;
char s[maxN];
ll ans;
struct node
{
    ll val, pos, cnt_A, cnt_B;
    node(ll a=0, ll b=0, ll c=0, ll d=0):val(a), pos(b), cnt_A(c), cnt_B(d) {}
} Stap[maxN];
ll num_AB[2], tmp_AB[2];
inline void solve()
{
    Stop = 0;
    memset(num_AB, 0, sizeof(num_AB));
    for(int i=1; i<=sa.n - 1; i++)
    {
        if(sa.height[i] < K)    //小于K的时候直接算里面的贡献即可
        {
            while(Stop)
            {
                tmp_AB[0] = Stap[Stop - 1].cnt_A; tmp_AB[1] = Stap[Stop - 1].cnt_B;
                tmp_AB[sa.sa[Stap[Stop - 1].pos] > N_mid] --;
                ans += 1LL * (Stap[Stop].val - Stap[Stop - 1].val) * (num_AB[0] - tmp_AB[0]) * (num_AB[1] - tmp_AB[1]);
                Stop--;
            }
            num_AB[sa.sa[i] > N_mid] ++;
            Stap[0] = node(K - 1, i, num_AB[0], num_AB[1]);
            continue;
        }
        while(Stop && sa.height[i] < Stap[Stop].val)
        {
            tmp_AB[0] = Stap[Stop - 1].cnt_A; tmp_AB[1] = Stap[Stop - 1].cnt_B;
            tmp_AB[sa.sa[Stap[Stop - 1].pos] > N_mid] --;
            ans += 1LL * (Stap[Stop].val - max(Stap[Stop - 1].val, 1LL * sa.height[i])) * (num_AB[0] - tmp_AB[0]) * (num_AB[1] - tmp_AB[1]);
            Stop--;
        }
        num_AB[sa.sa[i] > N_mid] ++;
        if(sa.height[i] > Stap[Stop].val) Stap[++Stop] = node(sa.height[i], i, num_AB[0], num_AB[1]);
        else if(sa.height[i] == Stap[Stop].val) { Stap[Stop].cnt_A = num_AB[0]; Stap[Stop].cnt_B = num_AB[1]; Stap[Stop].pos = i; }
    }
}
int main()
{
    while(scanf("%d", &K) && K)
    {
        sa.clear(); ans = 0;
        scanf("%s", s + 1);
        len = (int)strlen(s + 1);
        for(int i=1; i<=len; i++) sa.s[++sa.n] = s[i];
        sa.s[++sa.n] = 'a' + 26;
        N_mid = sa.n;
        scanf("%s", s + 1);
        len = (int)strlen(s + 1);
        for(int i=1; i<=len; i++) sa.s[++sa.n] = s[i];
        sa.s[++sa.n] = 'a' + 27;
        sa.get_SA();
//        for(int i=1; i<=sa.n; i++) printf("%d ", sa.sa[i]); puts("");
        sa.get_height();
//        for(int i=1; i<=sa.n; i++) printf("%d ", sa.height[i]); puts("");
        solve();
        printf("%lld\n", ans);
    }
    return 0;
}

 

警示语：以后一定要记住单调栈相等元素的处理问题！在这上面犯错了…… 

Wuliwuliii
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
poj 3415 后缀数组+单调栈
weixin_30832405的博客
12-07 77
题目大意： 求两个字符串的长度大于k的公共子串的个数（可以相同） 基本思路： 后缀数组+单调栈，就是降低复杂度到O（n）； 代码如下： #include<cstdio> #include<cstring> using namespace std; typedef long long ll; const int inf = 0x3f3f3f3f; ...
Common Substrings（后缀数组+单调栈）
永夜莫明的博客
08-28 660
https://cn.vjudge.net/problem/POJ-3415 A substring of a string T is defined as: T( i, k)= TiTi +1... Ti+k -1, 1≤ i≤ i+k-1≤| T|. Given two strings A, B and one integer K, we define S, a set o...
Common Substrings （求有多少个长度大于K的公共子串。）
qq_45778406的博客
04-16 204
链接 POJ - 3415 题意：给出两个字符串s1、s2和一个整数K，求有多少个长度大于K的公共子串。 思路： 参考题解： 现将s = s1 + ‘$’ + s2;(做出后缀数组) 有后缀数组height的特性可知可将排名1~n的后缀串通过是否公共子串大于k来分组 我们只需求出每一组中的长度大于K的公共子串， 在相加即可得到答案； 对于每一组 朴素方法： 枚举组内的每一个s1中的后缀再枚举在该组中的每一个s2中的后缀, 答案为（height[i] - k + 1) * (height[j] - k +
POJ - 3415 Common Substrings（长度不小于K的公共子串个数）
Fighting_Peter的博客
10-20 137
#include<cstdio> #include<cstring> #include<iostream> using namespace std; typedef long long ll; // sa[i]: 排名是i位的是第几个后缀 // rk[i]: 第i个后缀的排名是多少 // height[i]: sa[i]与sa[i-1] const int N=200010; char s[N],s1[N],s2[N]; int rk[N],sa[N],cnt[N],he
POJ 3415 Common Substrings
dielie6462的博客
12-06 80
本篇是罗穗骞《后缀数组——处理字符串的有力工具》的读书笔记。 解题思路： 　　先把\(A, B\)两个字符串连接起来，中间用一个非拉丁字母隔开，组成一个大字符串。预处理出该字符串的后缀数组和高度数组。 　　扫描第一次高度数组，维护第一个单调栈，记录 \(A\) 的 “高度值”\(lcp\)（栈顶最小）和对应这个 \(lcp\) 的 \(A\) 的后缀个数 \(size\). 当让一...
字符串数组 matlab
06-23
在MATLAB中，字符串数组是一种重要的数据结构，它允许用户以数组的形式存储和处理文本数据。与传统的数值数组不同，字符串数组专门设计用于处理字符序列，提供了丰富的文本操作功能。以下将详细介绍字符串数组的创建...
LeetCode:Leetcode-解决方案
05-09
================ LeetCode ================动态编程1.... Palindromic Substrings [647]9. Maximum Length of Pair Chain [646]10. Integer Break [343]11. Count Numbers with Unique Digits [357]12. 2-Key
Java实现 蓝桥杯 算法提高VIP Substrings（暴力）
01-20
试题 算法提高 Substrings 问题描述 　You are given a number of case-sensitive strings of alphabetic characters, find the largest string X, such that either X, or its inverse can be found as a substring...
linear-substrings：线性时间算法，用于查找任何给定String的任何子长度的词典上最后的子字符串
02-19
线性子串给定任何字符串S，该算法将在O（n）时间内确定S的字典顺序上的最后一个子字符串，其中n = S的长度。 附加的功能： -给定任何长度L，以使0 <= L <= n，该算法将在O（n）时间内按字典顺序确定S的长度L的...
c代码-计算 ab ba的个数
07-14
在C语言中，字符串是以字符数组的形式存在的，可以通过遍历数组来查找子串。这个程序可能使用了两种主要的搜索方法：顺序搜索或KMP（Knuth-Morris-Pratt）算法。顺序搜索是最简单的，逐个比较字符直到找到匹配的子串...
POJ - 3415 Common Substrings (后缀数组）
weixin_30617695的博客
07-13 132
A substring of a stringTis defined as: T(i,k)=TiTi+1...Ti+k-1, 1≤i≤i+k-1≤|T|. Given two stringsA,Band one integerK, we defineS, a set of triples (i,j,k): S= {(i,j,k...
poj3415 Common Substrings
Gzb1128的栖息地
11-11 166
Description A substring of a string T is defined as: T(i,k)=TiTi+1...Ti+k−1,1≤i≤i+k−1≤∣T∣.T( i, k)= T_iT_{i +1}... T_{i+k -1}, 1≤ i≤ i+k-1≤| T|.T(i,k)=Ti​Ti+1​...Ti+k−1​,1≤i≤i+k−1≤∣T∣. Given two strings A, B and one integer K, we define S, a set of triples
POJ - 3415 Common Substrings(后缀数组求长度不小于 k 的公共子串的个数+单调栈优化)
那些年
09-29 1405
Description A substring of a string T is defined as: T( i, k)= TiTi+1... Ti+k-1, 1≤ i≤ i+k-1≤| T|. Given two strings A, B and one integer K, we define S, a set of triples (i, j, k): S =
POJ 3415 Common Substrings(后缀数组+单调栈)
窝不是爱酱,喵~~~~
09-05 7222
转载请注明出处，谢谢http://blog.csdn.net/acm_cxlove/article/details/7854526       by---cxlove  题目：求出长度不小于k的公共子串个数 http://poj.org/problem?id=3415  继续论文上的题目。 计算A的某个后缀与B的某个后缀的最长公共前缀长度，如果长度L大于k，则加上L-k+1组。
POJ - 3415 Common Substrings（后缀数组 + 单调栈）
Top_xiao的博客
08-18 357
题意： 求两个子串的大于等于k 的重复子串有多少个。 { 求两个子串的重复子串我们可以用单调栈来做， 然而，在同一个子串中，我们想要找重复子串的个数，那就是 height数组之和。 } 思路： 两个子串，我们用后缀数组维护，把两个子串合并在一起，然后中间加一个特殊字符。 {  看网上别人的博客。 一个n长度的子串，我们把后边填一个0，就是在位置n上加0， 这个字符串我们从 0 编...
最长公共子串（Longest Common SubStrings）
wind14的博客
01-24 297
Description给出两个字符串，求出两个字符串的公共子串？sample Inputencodingmy mydecodingsample Outputcoding两种方法：//暴力求解最长公共子串 public static void enumString(char[]s1 ,char[]s2){ int run_Count = 0;//运行次数 in
POJ 3415 Common Substrings【后缀自动机】
Mr.Phoebe的专栏
09-18 874
max：即代码中 len 变量，它表示该状态能够接受的最长的字符串长度。 min：表示该状态能够接受的最短的字符串长度。实际上等于该状态的 fail 指针指向的结点的 len + 1。 max-min+1：表示该状态能够接受的不同的字符串数。 right：表示节点u所能够接受的字符，在原字符串中出现过多少次 right*(max-min+1)就是节点u能够接受的字符串在原字符串中出现的次数。
lua将字符串逗号分隔转换为数字数组
最新发布
07-01
要将一个用逗号分隔的字符串转换为数字数组，可以使用Lua中的string和table库函数。下面是一个示例代码： ```lua -- 定义一个用逗号分隔的字符串 local str = "1,2,3,4,5" -- 使用string库函数split将字符串分隔...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wuliwuliii

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

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

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

打赏作者

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

抵扣说明：

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

余额充值