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.csdn.net/lwfcgz/article/details/48739051
2.http://blog.csdn.net/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;
      }