Manacher以及回文树算法学习

最新推荐文章于 2019-08-21 22:53:34 发布

转载最新推荐文章于 2019-08-21 22:53:34 发布 · 108 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jiachinzhao/p/7826498.html

本文详细介绍了Manacher算法及回文树的基本原理、构造方法及应用实践，包括算法核心思想、步骤详解及代码实现，并附有典型例题解析。

Manacher以及回文树算法学习

一、Manacher

关于$Manacher$,这篇博客
讲的很清楚。
大致总结一下
为了将长度为奇数的回文串和长度为偶数的回文串一起考虑，需要在原字符串中插入间隔字符，首尾也需要，处理后字符串长度为$2 * len + 1$
$Manacher$算法用一个辅助数组$Len[i]$表示以字符$T[i]$为中心的最长回文字串的最右字符到T[i]的长度，比如以$T[i]$为中心的最长回文字串是$T[l,r]$,那么$Len[i]=r-i+1$,
而且回文串在原字符串中的长度就为$Len[i]-1$
如何从左往右计算$Len[i]$，考虑中心在i之前的最长回文串，
假设该最长回文串中心为$center(center < i)$，且其向右延伸到了$mx$
若$ i < mx $ 由于$i$关于$center$ 对称的位置 $2 * center - i$已经计算过,显然$Len[i]$至少可以和$min(mx - i,Len[2 * center - i])$相等
然后再暴力比较计算，同时更新$mx和center$

$O(n)$复杂度证明见知乎
感觉这一份证明比较清晰

$下面尝试下证明。$

$设比较第 i 个字符时比较次数为 f(i) ，此时 max 的位置记为 \left( max\right)_{i-1} (上一次比较后 max 的位置)。比较完成后 max 的位置记为 \left( max\right)_{i} 。$

$f(i)=\left( max\right)_{i}-i(i>\left( max\right)_{i-1})$
$f(i)=\left( max\right)_{i}-\left( max\right)_{i-1}or0(i\leq\left( max\right)_{i-1})$

总比较次数 $f=\sum_{0}^{n-1}{f(i)}\leq\sum_{0}^{n-1}{(max)_{i}}-{(max)_{i-1}}\leq n$

$所以Manacher算法的复杂度是严格 O(n)的$

const int maxn=1000010;
char str[maxn];//原字符串
char tmp[maxn<<1];//转换后的字符串
int Len[maxn<<1];
//转换原始串
int INIT(char *st)
{
    int i,len=strlen(st);
    tmp[0]='@';//字符串开头增加一个特殊字符，防止越界
    for(i=1; i<=2*len; i+=2)
    {
        tmp[i]='#';
        tmp[i+1]=st[i/2];
    }
    tmp[2*len+1]='#';
    tmp[2*len+2]='$';///字符串结尾加一个字符，防止越界
    tmp[2*len+3]=0;
    return 2*len+1;///返回转换字符串的长度
}
//Manacher算法计算过程
int MANACHER(char *st,int len)
{
    int mx=0,ans=0,po=0;///mx即为当前计算回文串最右边字符的最大值
    for(int i=1; i<=len; i++)
    {
        if(mx>i)
            Len[i]=min(mx-i,Len[2*po-i]);///在Len[j]和mx-i中取较小值
        else
            Len[i]=1;///如果i>=mx，要从头开始匹配
        while(st[i-Len[i]]==st[i+Len[i]])
            Len[i]++;
        if(Len[i]+i>mx)///若新计算的回文串右端点位置大于mx，要更新po和mx的值
        {
            mx=Len[i]+i;
            po=i;
        }
        ans=max(ans,Len[i]);
    }
    return ans-1;///返回Len[i]中的最大值-1即为原串的最长回文子串额长度
}

二、回文树

关于回文树,看完下面两篇博客应该就懂的差不多了

1.http://blog.youkuaiyun.com/lwfcgz/article/details/48739051
2.http://blog.youkuaiyun.com/u013368721/article/details/42100363?readlog
大致总结一下
1、回文树中有两种类型的边。

第一种类型的边上同时有字符做标记，比如：$u$和$v$通过带字符$X$的边连接起来，表示节点$u$所表示的回文串两边添加$X$字符可以得到$v$节点所表示的回文串。
另一种类型的边是后缀链接边$(suffix link)$。从$u$到$w$存在一条后缀链接边，当且仅当$w$节点所代表的回文串是$u$的后缀中最长的回文串，但$w$和$u$不能相同（后缀：包含最后一个字符的子串，$bcd$是$abcd$的后缀，但$bc$不是$abcd$的后缀)。
后缀连接边也即失配边，这是回文树构造中最关键的一点。

2、回文树的结点

它有两个根，一个根表示长度为-1的回文串，是我们为了方便操作加进去的，长度为1的回文串可以通过它左右两侧各添加一个字符得到。另一个根表示长度为0的回文串，即空串，这样就能保证实现奇偶长度回文串共存。

回文树除根以外的每个结点表示本质不同的回文串, 然后并不实际存储结点，只是通过长度和边来表示。

3、构造过程

每次添加一个字符，只是找出了当前的前缀中最长的后缀回文串，$cnt[i]$表示结点$i$本质不同的回文串个数, num[i]表示以节点i表示的最长回文串的最右端点为回文串结尾的回文串个数,num在添加的过程可以通过失配边实际算出，cnt需要最后反着在计数一遍。
代码模板时间复杂度和空间复杂度均为$O(字符集大小 * n)$

const int MAXN = 100005 ;
const int N = 26 ;

struct Palindromic_Tree {
    int next[MAXN][N] ;///next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
    int fail[MAXN] ;///fail指针，失配后跳转到fail指针指向的节点
    int cnt[MAXN] ; ///cnt[i]表示节点i表示的本质不同的串的个数（建树时求出的不是完全的，最后count()函数跑一遍以后才是正确的）
    int num[MAXN] ;///表示以节点i表示的最长回文串的最右端点为回文串结尾的回文串个数。
    int len[MAXN] ;///len[i]表示节点i表示的回文串的长度
    int S[MAXN] ;///存放添加的字符
    int last ;///指向上一个字符所在的节点，方便下一次add
    int n ;///字符数组指针
    int p ;///节点指针

    int newnode ( int l ) {//新建节点
        for ( int i = 0 ; i < N ; ++ i ) next[p][i] = 0 ;
        cnt[p] = 0 ;
        num[p] = 0 ;
        len[p] = l ;
        return p ++ ;
    }

    void init () {//初始化
        p = 0 ;
        newnode (  0 ) ;
        newnode ( -1 ) ;
        last = 0 ;
        n = 0 ;
        S[n] = -1 ;///开头放一个字符集中没有的字符，减少特判
        fail[0] = 1 ;
    }

    int get_fail ( int x ) {///和KMP一样，失配后找一个尽量最长的
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;
        return x ;
    }

    void add ( int c ) {
        c -= 'a' ;
        S[++ n] = c ;
        int cur = get_fail ( last ) ;///通过上一个回文串找这个回文串的匹配位置
        if ( !next[cur][c] ) {///如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode ( len[cur] + 2 ) ;///新建节点
            fail[now] = next[get_fail ( fail[cur] )][c] ;///和AC自动机一样建立fail指针，以便失配后跳转
            next[cur][c] = now ;
            num[now] = num[fail[now]] + 1 ;
        }
        last = next[cur][c] ;
        cnt[last] ++ ;
    }

    void count () {
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;

    }
} ;

练习题

TsinsenA1280. 最长双回文串
题意：找出一个最长的字符串满足$AB$形式，$AB$都是非空的回文串
思路：正着和反着插入一遍, 就能求出以$i$结尾和起始的最长回文串,$i$和$i+1$拼起来即可
.TsinsenA1255. 拉拉队排练
题意：给一个字符串，找出所有奇数长度的回文串，按长度降序排列，求出前$K$个回文串长度的乘积mod19930726
思路：回文树可以处理本质不同回文串的种类和每种的个数(结点表示种类,$cnt[i]$表示个数)，算一下就好了
TsinsenA1393. Palisection
题意：给一个字符串，在所有回文串选两个，他们有公共位置的方案数。
思路：正着做行不通，反着做答案就是总方案数减去不相交的方案数
这里用到了num数组，预处理正着插入算出以1~i为回文串结尾的回文串个数
反着再插入一遍，对应相乘就是不相交的方案数。

2014-2015 ACM-ICPC, Asia Xian Regional Contest G The Problem to Slow Down You
题意：给出两个字符串$A,B$，求$pair(A[i...j]=B[p...q]且都是回文串)$的对数
思路：第一种方法是分别建A,B两颗回文树，然后再在回文树上dfs统计答案
我的方法是插入到同一颗回文树中，先插完A,count计算完之后，插入字符串B,由于在同一颗回文树中，所以不能跨越B使用A的字符串，所以在get_fail的时候控制长度,这个时候在插入B之前生成的结点就可以统计数量了，最后再乘起来。

  #include<bits/stdc++.h>
  #define LL long long
  using namespace std;

  const int MAXN = 4e5 + 10;
  const int SIZ = 26;

  LL res[MAXN];
  int z;
  struct Palindromic_Tree{
      int nxt[MAXN][SIZ];
      int fail[MAXN];
      LL cnt[MAXN];
      int num[MAXN];
      int len[MAXN];
      int S[MAXN];
      int last;
      int n;
      int tot;

      int newnode(int l){
          memset(nxt[tot], 0, sizeof nxt[tot]);
          cnt[tot] = num[tot] = 0;
          len[tot] = l;
          res[tot] = 0;
          return tot++;
      }

      void init(){
          tot = 0;
          newnode( 0 );
          newnode( -1 );
          last = 0;
          n = 0;
          S[n] = -1;
          fail[0] = 1;
      }
      int get_fail(int x){
          while(S[n - len[x] - 1] != S[n] ) x = fail[x];
          return x;
      }
      int get_failB(int l, int x){
          while(S[n - len[x] - 1] != S[n] || l - len[x] - 2 < 0) x = fail[x];
          return x;
      }
      void addA(int c){
          c -= 'a';
          S[++n] = c;
          int cur = get_fail( last );
          if(!nxt[cur][c]){
              int now = newnode( len[cur] + 2);
              fail[now] = nxt[get_fail( fail[cur] )][c];
              nxt[cur][c] = now;
              num[now] = num[fail[now]] + 1;
          }
          last = nxt[cur][c];
          cnt[last]++;
      }
      void addB(int l,int c){
          c -= 'a';
          S[++n] = c;
          int cur = get_failB( l, last );
          if(!nxt[cur][c]){
              int now = newnode( len[cur] + 2);
              fail[now] = nxt[get_fail( fail[cur] )][c];
              nxt[cur][c] = now;
              num[now] = num[fail[now]] + 1;
          }
          last = nxt[cur][c];
          res[last]++;
      }
      void count(){
          for(int i = tot - 1;i >= 0;i--) cnt[fail[i]] += cnt[i];
      }
  } Pali;
  char sA[MAXN],sB[MAXN];

  int main(){

      int T, cas = 1;
      cin>>T;
      while(T--){
          scanf("%s%s", sA, sB);
          Pali.init();
          int lenA = strlen(sA);
          for(int i = 0;i < lenA;i++) Pali.addA(sA[i]);
          Pali.count();
          z = Pali.tot;
          int lenB = strlen(sB);
          for(int i = 0;i < lenB;i++) Pali.addB(i + 1, sB[i]);
          for(int i = Pali.tot - 1;i >= 0;i--) res[Pali.fail[i]] += res[i];
          LL ans = 0;
          for(int i = 2;i < z;i++) ans += res[i] * Pali.cnt[i];
          printf("Case #%d: %lld\n",cas++,ans);
      }
      return 0;
  }

转载于:https://www.cnblogs.com/jiachinzhao/p/7826498.html

Manacher以及回文树算法学习

Manacher以及回文树算法学习

一、Manacher

二、 回文树

二、回文树