HDU 3518 && HDU 4416【后缀自动机len的使用】

最新推荐文章于 2019-09-25 09:23:00 发布
最新推荐文章于 2019-09-25 09:23:00 发布
阅读量1.4k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 前缀 & 后缀
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013007900/article/details/48048859
本文探讨了后缀自动机在处理字符串匹配问题中的应用，特别关注如何利用后缀自动机解决不相交子串问题及计算特定条件下不同子串的数量，并通过实例分析了算法实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

max：即代码中 len 变量，它表示该状态能够接受的最长的字符串长度。
min：表示该状态能够接受的最短的字符串长度。实际上等于该状态的 fail 指针指向的结点的 len + 1。
max-min+1：表示该状态能够接受的不同的字符串数。

那么在HDU 3518 中。
求的是，不相交且出现次数大于2的子串个数。
我们这么想，如果你把一个串直接塞进后缀自动机里面，比较难以处理（不是没有办法，只是我看不太懂那是怎么回事）不相交的问题。那么我们就想到将字符串拆成两部分，然后两部分分别hash，在一个串里找另一个串中是否存在一个hash值，这样就必然是不相交的，如果找到了相同的hash值，则是在两个字符串中各出现了一次，在原串中出现两次。但是这么做会TLE。
于是，就通过后缀自动机中的len来计数。
最上面讲过了len[u]-len[fa[u]]+1 表示能够接受的不同串的个数，那么就是规定了一个上届和下届，如果我们把上届或者下届的意义改了，就可以计算我们需要的串的个数了。
在这题中，我们将串拆成两部分，第一部分塞进后缀自动机，用后一部分来匹配，匹配每一个节点能够匹配的最远距离mi[u]，那么讲状态u接受的字符串区间分成了两部分(len[fa[u]],mi[u]]和(mi[u],len[u]]，很明显，前面是后半部分能够匹配的那部分串，后面是不能匹配的。那么我们需要的就是将每个节点的(len[fa[u]],mi[u]]部分加起来就行了。

同时还要注意的是，从u→fa[u]累加的情况。fail指针，指向了一个能够表示当前状态表示的所有字符串的最长公共后缀的结点。简单说，就是fail指针指向了一个v，从v到root表示的串是u到root表示的串中的一部分，然后要求的是最长。
那么也就是说，如果str在u这个状态匹配了mi[u]，那么str很可能在fa[u]也匹配了mi[u]（当然有些情况下，mi[u]会超过len[fa[u]]，可以直接取min），所以必须要累加过去。

//      whn6325689
//      Mr.Phoebe
//      http://blog.youkuaiyun.com/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=2010;
const int MAC=26;

struct SAM
{
    int len[MAXN],next[MAXN][MAC],fa[MAXN],L,last;
    int sum[MAXN],topo[MAXN];
    int mi[MAXN];
    SAM(){init();}
    void init()
    {
        L=0;last=newnode(0,-1);
    }
    int newnode(int l,int pre)
    {
        fa[L]=pre;
        mi[L]=0;
        for(int i=0;i<MAC;i++)  next[L][i]=-1;
        len[L]=l;
        return L++;
    }
    void add(int x)
    {
        int pre=last,now=newnode(len[pre]+1,-1);
        last=now;
        while(~pre && next[pre][x]==-1)
        {
            next[pre][x]=now;
            pre=fa[pre];
        }
        if(pre==-1) fa[now]=0;
        else
        {
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1)    fa[now]=bro;
            else
            {
                int fail=newnode(len[pre]+1,fa[bro]);
                memcpy(next[fail],next[bro],sizeof next[bro]);
                fa[bro]=fa[now]=fail;
                while(~pre && next[pre][x]==bro)
                {
                    next[pre][x]=fail;pre=fa[pre];
                }
            }
        }
    }

    void toposort()
    {
        CLR(sum,0);
        for(int i=0;i<L;i++)    sum[len[i]]++;
        for(int i=1;i<L;i++)    sum[i]+=sum[i-1];
        for(int i=0;i<L;i++)    topo[--sum[len[i]]]=i;
    }

    void query(char *S)
    {
        int u=0,x,cnt=0;
        for(char *sp=S;*sp;sp++)
        {
            x=*sp-'a';
            if(~next[u][x])
            {
                u=next[u][x];
                mi[u]=max(mi[u],++cnt);
            }
            else
            {
                while(~u && next[u][x]==-1)
                    u=fa[u];
                if(u==-1)
                    cnt=0,u=0;
                else
                {
                    cnt=len[u]+1;
                    u=next[u][x];
                    mi[u]=max(mi[u],cnt);
                }
            }
        }
    }

    int build()
    {
        int ans=0;
        toposort();
        for(int i=L-1;i>=0;i--)
        {
            int u=topo[i];
            if(~fa[u])
                mi[fa[u]]=max(mi[fa[u]],mi[u]);
        }
        for(int i=0;i<L;i++)
        {
            mi[i]=min(mi[i],len[i]);
            if(~fa[i] && mi[i]>len[fa[i]])
                ans+=(mi[i]-len[fa[i]]);
        }
        return ans;
    }
}T;

char str[MAXN];

int main()
{
    while(scanf("%s",str)!=EOF && str[0]!='#')
    {
        int le=strlen(str);
        T.init();
        for(int i=1;i<le;i++)
        {
            T.add(str[i-1]-'a');
            T.query(str+i);
        }
        printf("%d\n",T.build());
    }
    return 0;
}

在HDU 4416中
求的是A这个字符串，有多少各子串在Bi中没有出现过。
上一题求的是出现过的，这一题求的是没有出现过的。
同样的分析，最终将区间分成两部分(len[fa[u]],mi[u]]和(mi[u],len[u]]，很明显，前面是出现过的，后面是没出现过的，于是我们需要将后面那部分加起来就行了。

//      whn6325689
//      Mr.Phoebe
//      http://blog.youkuaiyun.com/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=(100010<<1);
const int MAC=26;

struct SAM
{
    int len[MAXN],next[MAXN][MAC],fa[MAXN],L,last;
    int mi[MAXN];
    SAM()
    {
        init();
    }
    void init()
    {
        L=last=0;
        newnode(0,-1);
    }
    int newnode(int l,int pre)
    {
        fa[L]=pre;
        for(int i=0; i<MAC; i++)    next[L][i]=-1;
        len[L]=l;
        mi[L]=0;
        return L++;
    }
    void build(const char* p)
    {
        int le=strlen(p);
        for(int i=0; i<le; i++)
            add(p[i]-'a');
        toposort();
    }
    void add(int x)
    {
        int pre=last,now=newnode(len[pre]+1,-1);
        last=now;
        while(~pre && next[pre][x]==-1)
        {
            next[pre][x]=now;
            pre=fa[pre];
        }
        if(pre==-1) fa[now]=0;
        else
        {
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1)    fa[now]=bro;
            else
            {
                int fail=newnode(len[pre]+1,fa[bro]);
                for(int i=0; i<MAC; i++)    next[fail][i]=next[bro][i];
                fa[bro]=fa[now]=fail;
                while(~pre && next[pre][x]==bro)
                {
                    next[pre][x]=fail;
                    pre=fa[pre];
                }
            }
        }
    }
    int sum[MAXN],topo[MAXN];
    void toposort()
    {
        CLR(sum,0);
        for(int i=0; i<L; i++)  sum[len[i]]++;
        for(int i=1; i<L; i++)  sum[i]+=sum[i-1];
        for(int i=0; i<L; i++)  topo[--sum[len[i]]]=i;
    }

    void query(const char* S)
    {
        int u=0,x,cnt=0;
        for(const char* sp=S; *sp; sp++)
        {
            x=*sp-'a';
            if(~next[u][x])
            {
                u=next[u][x];
                mi[u]=max(mi[u],++cnt);
            }
            else
            {
                while(~u && next[u][x]==-1)
                    u=fa[u];
                if(u==-1)
                    cnt=0,u=0;
                else
                {
                    cnt=len[u]+1;
                    u=next[u][x];
                    mi[u]=max(mi[u],cnt);
                }
            }
        }
    }
} T;

char str[MAXN];
int q,k;


int main()
{
    int t,cas=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&q);
        T.init();
        scanf("%s",str);
        T.build(str);
        while(q--)
        {
            scanf("%s",str);
            T.query(str);
        }
        for(int i=T.L-1; i>=1; i--)
        {
            int u=T.topo[i];
            if(T.mi[u]>0)
                T.mi[T.fa[u]]=max(T.mi[T.fa[u]],T.mi[u]);
            else
                T.mi[u]=T.len[T.fa[u]];
        }
        ll ans=0;
        for(int i=1; i<T.L; i++)
            if(T.len[i]>T.mi[i])
                ans+=T.len[i]-T.mi[i];
        printf("Case %d: %lld\n",cas++,ans);
    }
    return 0;
}
K-th occurrence 2019CCPC网络赛+HDU6704（后缀自动机+主席树）
UniverseofHK的博客
11-05 390
K-th occurrence 之前网络赛跟队友合体出的题，当时我写的后缀自动机，他写的主席树，hhh！ 现在我会写主席树，他会写后缀数组，于是各自独立的A了！并且我跟之前网络赛时的解法还不完全一样 巨佬队友bxd的后缀数组+主席树解法 题意： 给定一个串SSS，有QQQ个询问：求子串S[l,r]S[l,r]S[l,r]在SSS中的第kkk次出现位置。 思路： 由于后缀自动机可以知道某个子串的e...
2019HDU多校赛 第十场 HDU 6694 Play Games with Rounddog（后缀自动机 + 线性基）
alpc_qleonardo
08-23 677
大致题意：给你一个字符串S，然后q个询问，每次给出S的一个子串T。对于每个询问的子串T，Calabash可以在Ｓ中选择任意个以T作为后缀的子串，然后生成子串对应数目个石子堆，每堆的石子数量等于w[对应子串在S中出现的次数]。然后Rounddog可以从这么多堆石子中选择任意堆的石子（至少选一堆），两人开始玩Nim游戏，Calabash先手。现在问Calabash是否存在必胜策...
hdu3518——后缀自动机
cool_Fires的专栏
08-03 1494
题意：求一个字符串有多少个不同的子串满足出现了至少两次，且没有重叠。 去年作的时候用后缀数组过的，现在写了个后缀自动机。因为一个很脑残的bug（忘了按拓扑序递推）调了两个小时。不过也有收获，在纸上画了10多次建自动机过程之后理解的更清晰了。 做法是维护每个状态的最左出现的位置和最右出现的位置（逆拓扑序递推），如果这两个位置之间能放下某些该状态表示的字符串，这些子串加入我们的解中。 #incl
HDU 3518 Boring Counting 后缀数组/后缀自动机
とある黄鱼のOIブログ
02-16 817
分组height？半个月没动后缀数组一堆名词都忘了233#include <cstdio> #include <cstring> #include <algorithm> #define rep(i,j,k) for(i=j;i<k;i++) #define FOR(i,j,k) for(i=j;i<=k;i++) using std::min; using std::max; #define N
HDU 3518 Boring counting （后缀自动机）
aomen8092的博客
09-25 214
统计至少出现两次的不重叠子串的个数 后缀数组可做，所以我用后缀自动机 考虑到任意子串都包含在sam的某个状态中，所以对于某个状态st，只要| endpos(st) | >= 2 则状态中长度 <= ( max( endpos( st ) ) - min( endpos ( st ) )的子串都是满足条件的 所以只需要求出两个数组L[ i ]，R[ i ]，分别表示endpos...
HDU 3518 Boring counting（后缀自动机 SAM）
ddyyxx的程序员之路
03-24 1734
题意：求一个字符串中重复出现两次以上且不重叠的不同字串的个数。比如aaaa中 a和aa符合要求，而aaa和aaaa不符合要求。 思路：好像标程给的是后缀数组，但我是后缀自动机过的，我们只要在后缀自动机中的每一个状态里，设l,r分别表示在这个状态中的子串集合的最左与最右位置，num表示这个状态中的子串一共出现了多少次。 因为在后缀自动机中，每一个状态代表了一类子串，（设一个状态为p）它们的长度范
HDU 4622（后缀自动机）
weixin_30279671的博客
09-12 155
传送门 题面： czh得意的向cry炫耀自己的英文水平，cry很不屑的扔给czh一篇文章，虽然czh看完之后头晕眼花，但他还是决定猜测一下文章中单词的意思，由于文章连空格都没有，这大大增加了阅读的难度，于是他决定退而求其次，只需要计算一下从第L个字符到第R个字符中有多少个可能的互不相同单词（任意长度 >=1 ，任意组合的字符都是一个可能的单词）就行了，这时候就需...
后缀自动机SAM
ZigZagK的博客
07-05 1867
后缀自动机SAM总结。
HDU 6583 Typewriter 后缀自动机优化DP
lifelike
07-23 732
Typewriter Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 108 Accepted Submission(s): 22 Problem Description One day, Jerry found a stran...
HDU 4622 Reincarnation （区间不相同子串个数：字符串哈希 | 后缀数组 | 后缀自动机）
小坏蛋_千千
05-03 2008
Problem Description Now you are back,and have a task to do: Given you a string s consist of lower-case English letters only,denote f(s) as the number of distinct sub-string of s. And you ha
HDU4416(后缀自动机)
ACdreamer
08-31 3090
题目：http://acm.hdu.edu.cn/showproblem.php?pid=4416   题目大意：给一个字符串S和一系列字符串T1~Tn，问在S中有多少个不同子串满足它不是T1~Tn中任意一个字符串的子串。 #include #include #include #include using namespace std; typedef long long
hdu3518
slow_yangyang的博客
08-13 702
大致题意：给出一个字符串，求该字符串的子串能在该串中出现2次以上且不重叠的子串有几种 测试案例： input： aaaa ababcabb aaaaaa # output： 2 3 3 解题思路：这题我是用后缀数组做的，具体的后缀数组怎么生成我也不懂，是直接套模板的，这题我通过案例ababcabb这个字符串来讲下我的程序是怎么处理的。 首先，sa这个数组存的是后
HDU3518
woshizhazha的专栏
02-21 706
//具体的文章分析可以看这个http://www.acmerblog.com/hdu-3518-boring-counting-6479.html #include #include #include using namespace std; const int maxn=1100; int wa[maxn],wb[maxn],wsf[maxn],wv[maxn],sa[maxn]; int
HDU 3518 Boring counting 后缀自动机
Gatevin的专栏
05-05 895
题目大意： 就是对于给出的字符串S, 长度不超过1000, 求其中本质不同的子串的数量, 这些子串满足在字符串S中出现了至少不重合的2次 大致思路： 如果将S建立后缀自动机的话, 记录每个节点处的串最早一次和最后一次出现的位置, 然后状态 t 处的字符串长度为[Min(t), Max(t)]比较其和rightmost - leftmost 的大小即可知道这个状态下有多少满足条件的串
HDU 4416 (后缀自动机)
aekijekzn484879763的博客
07-21 244
HDU 4416 Good Article Good sentence Problem : 给一个串S，和一些串T，询问S中有多少个子串没有在T中出现。 Solution :首先对所有的T串建立后缀自动机，统计出本质不同的子串个数ans1，再将S串插入后缀自动机，统计出本质不同的子串个数ans2，则答案即为ans2-ans1。 将多个串插入后缀自动机，只需要每次将last赋值为root即...
HDU 3518
weixin_30672295的博客
05-16 110
http://acm.hdu.edu.cn/showproblem.php?pid=3518 trie View Code 1 #include<cstdio> 2 #include<cstring> 3 #include<cstdlib> 4 #include<iostream> 5 #include<algor...
HDU3518(后缀数组）
qq_39861441的博客
04-02 238
题目：大致题意：给出一个字符串，求该字符串的子串能在该串中出现2次以上且不重叠的子串有几种 解题思路：不给原字符串末尾加一个比谁都小的数一直报错，我也是真的不太搞得懂。思路就是不断枚举长度，如果height[j]>=i,那就说明sa[j]和sa[j-1]之间的公共子串的长度高于所规定的的i长度，一定能够找出来长度为i的公共子串。 #include<cstdio> #incl...
HDU 6405 2018HDU多校赛 第八场 Make ZYB Happy（广义后缀自动机）
alpc_qleonardo
08-15 697
大致题意：给你n个字符串，然后每个字符串有一个快乐值。然后给你m个询问，每个询问给你一个长度，让你写出一个不大于这个长度的字串。这个字串的权值定义为，如果这个字符串中出现过第i个给定字符串的子串，那么权值乘以第i个字符串的快乐值，最后答案就是多个快乐值相乘。现在问你给定长度的字符串权值的期望。首先，我们考虑这个权值的分母是多少。显然长度不超过x，那就是说长度可以是1、2、...、x，对应26个字母，那么方案数就是。然后我们再来看分母。分母肯定是计算每一个长度的贡献，对于一个长度，他可以是很多个串的子串，所以
HDU&POJ图论题集更新版（至20120406）
对于HDU&&POJ图论题集，更新至20120406的版本意味着，这个题集包含了自那之前的所有图论相关的练习题目。解答这些题目需要对应的知识储备和编程技巧，通常包括： - 理解题目描述中的图论概念和问题需求； - 设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值