「TJOI / HEOI2016」字符串

题目链接

问题分析

看见字符串，还涉及到子串和前缀的，当然就想到了SAM(其实我不会SA)。

首先我们把串反一下，就变成了求S[a..b]的所有子串与S[c..d]的最长后缀的长度。

我们把问题说成这样：求是S[a..b]子串的S[c..d]的最长后缀长度。于是我们就可以二分答案，然后判定是否在S[a..b]中出现就可以啦！

考虑二分答案后如何判定

假设我们现在判断Len是否可行。我们首先找到一个SAM上的状态，它的Right集合中含有d这个位置，并且Len介于这个状态的MinLen和MaxLen之间。那么只需要查询Right集合中有没有a+Len-1到b的元素即可。

具体细节是这样的：首先我们应该在建SAM的时候直接保存d最早出现的状态。这个状态就是Right集合中含有d，并且在Parent树上深度最深的节点。然后对于一个长度Len，我们在Parent树上倍增，找到[MinLen..MaxLen]包含Len的节点，判断的后缀就包含在这个状态里。同时，如果这个状态的Right集合中有[a+Len-1..b]的元素，那么说明这个串也存在于[a..b]中，否则就没有。

所以我们需要线段树合并求Right集合。然后就做完了！

时间复杂度\(O(n\log^2n)\)。

参考程序

我不知道为什么写的这么翔

#include <bits/stdc++.h>
//#ifndef DEBUG
//	#define DEBUG
//#endif
using namespace std;

const int Maxn = 100010;
const int MaxLog = 20;
int n, m;
char Ch[ Maxn ];
int Index[ Maxn ];

namespace Seg { //线段树
	struct segmentTree {
		segmentTree *LeftChild, *RightChild;
		int Num;
		void Init() {
			Num = 0;
			LeftChild = RightChild = NULL;
		}
	};
	segmentTree *SegmentTree[ Maxn << 1 ];

	void Init() {
		for( int i = 0; i < Maxn << 1; ++i )
			SegmentTree[ i ] = NULL;
		return;
	}

	segmentTree *Insert( segmentTree *Index, int Left, int Right, int Key ) {
		if( Index == NULL ) {
			Index = new segmentTree;
			Index -> Init();
		}
		++Index -> Num;
		if( Left == Right ) return Index;
		int Mid = ( Left + Right ) >> 1;
		if( Key <= Mid ) Index -> LeftChild = Insert( Index -> LeftChild, Left, Mid, Key );
		if( Key > Mid ) Index -> RightChild = Insert( Index -> RightChild, Mid + 1, Right, Key );
		return Index;
	}

	void Insert( int Pos, int Key ) {
#ifdef DEBUG
		printf( "Inform(Seg) : Add [ %d ] -> [ %d ]\n", Key, Pos );
#endif
		SegmentTree[ Pos ] = Insert( SegmentTree[ Pos ], 1, n, Key );
		return;
	}

	segmentTree *Merge( segmentTree *x, segmentTree *y, int Left, int Right ) {
		if( x == NULL && y == NULL ) return x;
		if( x != NULL && y == NULL ) return x;
		segmentTree *z = new segmentTree;//注意要新建节点
		if( x == NULL && y != NULL ) {
			*z = *y;
			return z;
		}
		*z = *x;
		z -> Num += y -> Num;
		if( Left == Right ) return z;
		int Mid = ( Left + Right ) >> 1;
		z -> LeftChild = Merge( z -> LeftChild, y -> LeftChild, Left, Mid );
		z -> RightChild = Merge( z -> RightChild, y -> RightChild, Mid + 1, Right );
		return z;
	}//线段树合并求Right集合

	void Play( segmentTree *Index, int Left, int Right ) {
		if( Index == NULL ) return;
		if( Index -> Num == 0 ) return;
		if( Left == Right ) {
			printf( "%d ", Left );
			return;
		}
		int Mid = ( Left + Right ) >> 1;
		Play( Index -> LeftChild, Left, Mid );
		Play( Index -> RightChild, Mid + 1, Right );
		return;
	}//Debug用

	void Merge( int x, int y ) {
#ifdef DEBUG
		printf( "Inform(Seg) : Merge %d <-- %d\n", x, y );
#endif
		SegmentTree[ x ] = Merge( SegmentTree[ x ], SegmentTree[ y ], 1, n );
#ifdef DEBUG
		printf( "  Right : " ); Play( SegmentTree[ x ], 1, n ); printf( "\n" );
#endif
		return;
	}//这是一个接口

	int Count( segmentTree *Index, int Left, int Right, int L, int R ) {
		if( Index == NULL ) return 0;
		if( L <= Left && Right <= R ) return Index -> Num;
		int Mid = ( Left + Right ) >> 1;
		int Ans = 0;
		if( L <= Mid ) Ans += Count( Index -> LeftChild, Left, Mid, L, R );
		if( R > Mid ) Ans += Count( Index -> RightChild, Mid + 1, Right, L, R );
		return Ans;
	}//求一段区间内的元素个数，用于判断区间内是否存在元素
} //Seg


namespace SAM {
	int Now, Used = 0, Last;
	struct suffixAutomaton {
		int Parent, Child[ 26 ], Len, MinLen;
	};
	suffixAutomaton SuffixAutomaton[ Maxn << 1 ];

	void Init() {
		Used = 0;
		memset( SuffixAutomaton, 0, sizeof( SuffixAutomaton ) );
		++Used; Last = Used;
		return;
	}

	void Insert( int t ) {
		Now = ++Used;
		SuffixAutomaton[ Now ].Len = SuffixAutomaton[ Last ].Len + 1;
		int p = Last;
		for( ; p && !SuffixAutomaton[ p ].Child[ t ]; p = SuffixAutomaton[ p ].Parent )
			SuffixAutomaton[ p ].Child[ t ] = Now;
		Last = Now;
		if( !p ) {
			SuffixAutomaton[ Now ].Parent = 1;
			return;
		}
		int q = SuffixAutomaton[ p ].Child[ t ];
		if( SuffixAutomaton[ p ].Len + 1 == SuffixAutomaton[ q ].Len ) {
			SuffixAutomaton[ Now ].Parent = q;
			return;
		}
		int Clone = ++Used;
		SuffixAutomaton[ Clone ].Len = SuffixAutomaton[ p ].Len + 1;
		SuffixAutomaton[ Clone ].Parent = SuffixAutomaton[ q ].Parent;
		for( int i = 0; i < 26; ++i )
			SuffixAutomaton[ Clone ].Child[ i ] = SuffixAutomaton[ q ].Child[ i ];
		for( ; p && SuffixAutomaton[ p ].Child[ t ] == q; p = SuffixAutomaton[ p ].Parent )
			SuffixAutomaton[ p ].Child[ t ] = Clone;
		SuffixAutomaton[ Now ].Parent = SuffixAutomaton[ q ].Parent = Clone;
		return;
	}
} //SAM

namespace Tree {//维护Parent树
	struct edge {
		int To, Next;
	};
	edge Edge[ Maxn << 2 ];
	int Start[ Maxn << 1 ], Used = 0;
	int Deep[ Maxn << 1 ], D[ Maxn << 1 ][ MaxLog ];//倍增需要的数组

	inline void AddEdge( int x, int y ) {
#ifdef DEBUG
		printf( "Inform(Tree) : Link %d <---> %d\n", x, y );
#endif
		Edge[ ++Used ] = ( edge ) { y, Start[ x ] };
		Start[ x ] = Used;
		return;
	}

	void Build( int Index, int Father ) {//建树，顺便求出MinLen
		D[ Index ][ 0 ] = Father;
		Deep[ Index ] = Deep[ Father ] + 1;
		if( Index > 1 )
			SAM::SuffixAutomaton[ Index ].MinLen = SAM::SuffixAutomaton[ Father ].Len + 1;
		for( int i = 1; i < MaxLog; ++i ) 
			D[ Index ][ i ] = D[ D[ Index ][ i - 1 ] ][ i - 1 ];
		for( int t = Start[ Index ]; t; t = Edge[ t ].Next ) {
			int v = Edge[ t ].To;
			if( v == Father ) continue;
			Build( v, Index );
		}
		return;
	}

	void Init() {
		for( int i = 2; i <= SAM::Used; ++i ) {
			AddEdge( SAM::SuffixAutomaton[ i ].Parent, i );
			AddEdge( i, SAM::SuffixAutomaton[ i ].Parent );
		}
		Build( 1, 1 );
		return;
	}

	void Union( int Index, int Father ) {
		for( int t = Start[ Index ]; t; t = Edge[ t ].Next ) {
			int v = Edge[ t ].To;
			if( v == Father) continue;
			Union( v, Index );
			Seg::Merge( Index, v );
		}
		return;
	}//求Right集合

	void Union() {
		Union( 1, 1 );
		return;
	}//这是一个接口

	void Play( int Index, int Father ) {
		printf( "Index = %d, Father = %d\n", Index, Father );
		printf( "  Min = %d, Max = %d\n", SAM::SuffixAutomaton[ Index ].MinLen, SAM::SuffixAutomaton[ Index ].Len );
		printf( "  Right : " );
		Seg::Play( Seg::SegmentTree[ Index ], 1, n );
		printf( "\n" );
		for( int t = Start[ Index ]; t; t = Edge[ t ].Next ) {
			int v = Edge[ t ].To;
			if( v == Father ) continue;
			Play( v, Index );
		}
		return;
	}//Debug用
} //Tree

void Debug() {
	printf( "Total Used Point in SAM : %d\n", SAM::Used );
	Tree::Play( 1, 0 );
	printf( "Start : " );
	for( int i = 1; i <= n; ++i ) printf( "%d ", Index[ i ] );
	printf( "\n\n\n" );
	system( "pause" );
	return;
}

void Read() {
	scanf( "%d%d", &n, &m );
	scanf( "%s", Ch + 1 );
	for( int i = 1; i + i <= n; ++i ) 
		swap( Ch[ i ], Ch[ n - i + 1 ] );
#ifdef DEBUG
	printf( "%d %d\n", n, m );
	printf( "%s\n", Ch + 1 );
	system( "pause" );
#endif
	return;
}

void Build() {
	Seg::Init();
	SAM::Init();
	for( int i = 1; i <= n; ++i ) {
		SAM::Insert( Ch[ i ] - 'a' );
		Index[ i ] = SAM::Now;//存下Right集合包含位置i并且在Parent树中深度最深的点
		Seg::Insert( SAM::Now, i );//插入位置i
	}
	Tree::Init();
#ifdef DEBUG
	Debug();
#endif
	Tree::Union();
#ifdef DEBUG
	Debug();
#endif
	return;
}

bool Check( int Len, int Index, int Left, int Right ) {
#ifdef DEBUG
	printf( "Inform(Check) : Len = %d, Left = %d, Right = %d, Index = %d\n", Len, Left, Right, Index );
	printf( "Inform(Check) : Min = %d, Max = %d\n", SAM::SuffixAutomaton[ Index ].MinLen, SAM::SuffixAutomaton[ Index ].Len );
#endif
	if( !Len ) return true;
	if( Len > SAM::SuffixAutomaton[ Index ].Len ) return false;
	if( SAM::SuffixAutomaton[ Index ].MinLen <= Len && Len <= SAM::SuffixAutomaton[ Index ].Len ) {
#ifdef DEBUG
		printf( "Count = %d\n", Seg::Count( Seg::SegmentTree[ Index ], 1, n, Left, Right ) );
#endif
		return Seg::Count( Seg::SegmentTree[ Index ], 1, n, Left, Right );
	}
	for( int i = MaxLog - 1; i >= 0; --i ) //倍增
		if( SAM::SuffixAutomaton[ Tree::D[ Index ][ i ] ].MinLen > Len )
			Index = Tree::D[ Index ][ i ];
	Index = Tree::D[ Index ][ 0 ];
#ifdef DEBUG
	printf( "Inform(Check) : Min = %d, Max = %d\n", SAM::SuffixAutomaton[ Index ].MinLen, SAM::SuffixAutomaton[ Index ].Len );
	printf( "Count = %d\n", Seg::Count( Seg::SegmentTree[ Index ], 1, n, Left, Right ) );
#endif
	return Seg::Count( Seg::SegmentTree[ Index ], 1, n, Left, Right );
}

void Solve() {
	for( int i = 1; i <= m; ++i ) {
		int a, b, c, d;
		scanf( "%d%d%d%d", &a, &b, &c, &d );
		a = n - a + 1; b = n - b + 1; c = n - c + 1; d = n - d + 1;
		swap( a, b ); swap( c, d );
		int Left = 0, Right = d - c + 1;
		while( Left < Right ) {//二分答案
			int Mid = ( Left + Right + 1 ) >> 1;
			if( Check( Mid, Index[ d ], a + Mid - 1, b ) ) Left = Mid; else Right = Mid - 1;
		}
		printf( "%d\n", Left );
	}
	return;
}

int main() {
	Read();
	Build();
	Solve();
	return 0;
}