练习——后缀数组题目

最新推荐文章于 2021-10-02 11:31:42 发布
最新推荐文章于 2021-10-02 11:31:42 发布
阅读量1.1k 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alxpcun/article/details/51258342
版权

BZOJ 1717.[Usaco2006 Dec]Milk Patterns 产奶的模式

题意：给一个字符串，求最长的出现至少K次的子串，子串可以重叠。

难度：*

和模型一样，直接上。

CODE:

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 20005;

int n, K, a[MAX_N];

void init()
{
	scanf("%d%d", &n, &K);
	for (int i = 0; i < n; i ++) scanf("%d", &a[i]), a[i] ++;
	a[n] = 0;
	//for (int i = 0; i < n; i ++) printf("%d ", a[i]); printf("\n");
}

int ws[1000005], wv[MAX_N], wa[MAX_N], wb[MAX_N];
int sa[MAX_N], H[MAX_N], R[MAX_N];

void da(int *a, int *sa, int n, int m) 
{
	int *x = wa, *y = wb;
	for (int i = 0; i < m; i ++) ws[i] = 0;
	for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;
	for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
	for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;
	for (int k = 1; k <= n; k <<= 1) {
		int p = 0;
		for (int i = n - k; i < n; i ++) y[p ++] = i;
		for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;
		for (int i = 0; i < n; i ++) wv[i] = x[y[i]];
		for (int i = 0; i < m; i ++) ws[i] = 0;
		for (int i = 0; i < n; i ++) ws[wv[i]] ++;
		for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
		for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];
		swap(x, y);
		p = 1; x[sa[0]] = 0;
		for (int i = 1; i < n; i ++) 
			x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;
		if (p >= n) break;
		m = p; 
	}
}

void calc()
{
	for (int i = 1; i <= n; i ++) R[sa[i]] = i;
	int k = 0, j;
	for (int i = 0; i < n; H[R[i ++]] = k)
		for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);
}

bool check(int x)
{
	int cnt = 1;
	for (int i = 2; i <= n; i ++) {
		if (H[i] < x) cnt = 1;
		else cnt ++;
		if (cnt >= K) return 1;
	}
	return 0;
}

void doit()
{
	da(a, sa, n + 1, 1000002);
	calc();
	int l = 0, r = n, mid;
	while (l <= r) {
		mid = (l + r) >> 1;
		if (check(mid)) l = mid + 1;
		else r = mid - 1;
	}
	printf("%d\n", r);
}

int main()
{
	//freopen("bzoj1717.in", "r", stdin);
	init();
	doit();
	return 0;
}

BZOJ 1692.[Usaco2007 Dec]队列变换

题意：给定一个字符串，每次从当前字符串的头，或者尾去一个字符，放入新字符串的尾部，求字典序最小的新字符串。

难度：**

首先每次比较头尾字符，然后去较小的加入的这个贪心方法是错误的。为什么？考虑当两个一样的时候，就不知道怎么办了。如果发现一样，继续往后枚举比较，这样的话最坏的时间复杂度为O(n)，非常不优美。其实我们枚举后面的字符比较，其实比的是后缀的大小，而这个顺序正好可以用后缀数组求出来。把字符串翻转，用经典方法把两个字符串拼接起来，因为取尾部的字符时实际上比较的是从后往前的”后缀“。然后求Rank数组。用两个指针搞一搞就O(n)解决了。

CODE：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 60005;

int n, a[MAX_N], l1;
char s[30005];

void init()
{
	scanf("%d", &n); getchar();
	l1 = n;
	for (int i = 0; i < n; i ++) 
		scanf("%c", &s[i]), getchar();
	for (int i = 0; i < n; i ++) a[i] = (int)s[i];
	a[n] = 1;
	for (int i = 0; i < n; i ++) a[n + n - i] = a[i];
	n = n * 2 + 1;
	a[n] = 0;
}

int ws[MAX_N], wv[MAX_N], wa[MAX_N], wb[MAX_N];
int sa[MAX_N], H[MAX_N], R[MAX_N];

void da(int *a, int *sa, int n, int m) 
{
	int *x = wa, *y = wb;
	for (int i = 0; i < m; i ++) ws[i] = 0;
	for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;
	for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
	for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;
	for (int k = 1; k <= n; k <<= 1) {
		int p = 0;
		for (int i = n - k; i < n; i ++) y[p ++] = i;
		for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;
		for (int i = 0; i < n; i ++) wv[i] = x[y[i]];
		for (int i = 0; i < m; i ++) ws[i] = 0;
		for (int i = 0; i < n; i ++) ws[wv[i]] ++;
		for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
		for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];
		swap(x, y);
		p = 1; x[sa[0]] = 0;
		for (int i = 1; i < n; i ++) 
			x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;
		if (p >= n) break;
		m = p; 
	}
}

void calc()
{
	for (int i = 1; i <= n; i ++) R[sa[i]] = i;
	int k = 0, j;
	for (int i = 0; i < n; H[R[i ++]] = k)
		for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);
}


void doit()
{
	da(a, sa, n + 1, 128);
	calc();
	//for (int i = 1; i <= n; i ++) printf("%d ", sa[i]); printf("\n");
	//for (int i = 0; i < n; i ++) printf("%d ", R[i]); printf("\n");
	int l = 0, r = l1 - 1, cnt = 0;
	while (l <= r) {
		int x = l, y = n - r - 1;
		//printf("%d %d\n", x, y);
		if (cnt == 80) printf("\n"), cnt = 0;
		if (R[x] < R[y])  printf("%c", s[l]), l ++, cnt ++;
		else  printf("%c", s[r]), r --, cnt ++;
	}
	printf("\n");
}

int main()
{
	freopen("bzoj1692.in", "r", stdin);
	init();
	doit();
	return 0;
}

BZOJ 2251.[2010Beijing Wc]外星联络

题意：给定一个01串，输出子串出现次数大于1次的次数，按子串的字典序输出。

难度：**~***

首先根据后缀数组的一些经典应用，我们可以知道每个后缀对子串个数的贡献是n-H[i]-sa[i]，而且顺序就是字典序，我们枚举每个子串暴力的用H数组前后求匹配：L为向前最多到哪，R为向后最多到哪，答案是R - L。其实还有更简单的Trie树做法。

CODE：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 3005;

int n, a[MAX_N];
char s[MAX_N];

void init()
{
	scanf("%d%s", &n, s);
	for (int i = 0; i < n; i ++) a[i] = s[i] - '0', a[i] ++;
	a[n] = 0;
}

int ws[MAX_N], wv[MAX_N], wa[MAX_N], wb[MAX_N];
int sa[MAX_N], H[MAX_N], R[MAX_N];

void da(int *a, int *sa, int n, int m) 
{
	int *x = wa, *y = wb;
	for (int i = 0; i < m; i ++) ws[i] = 0;
	for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;
	for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
	for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;
	for (int k = 1; k <= n; k <<= 1) {
		int p = 0;
		for (int i = n - k; i < n; i ++) y[p ++] = i;
		for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;
		for (int i = 0; i < n; i ++) wv[i] = x[y[i]];
		for (int i = 0; i < m; i ++) ws[i] = 0;
		for (int i = 0; i < n; i ++) ws[wv[i]] ++;
		for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];
		for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];
		swap(x, y);
		p = 1; x[sa[0]] = 0;
		for (int i = 1; i < n; i ++) 
			x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;
		if (p >= n) break;
		m = p; 
	}
}

void calc()
{
	for (int i = 1; i <= n; i ++) R[sa[i]] = i;
	int k = 0, j;
	for (int i = 0; i < n; H[R[i ++]] = k)
		for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);
}

void doit()
{
	da(a, sa, n + 1, 4);
	calc();
	for (int i = 1; i <= n; i ++) {
		for (int j = H[i] + 1; sa[i] + j - 1 < n; j ++) {
			int l, r;
			for (l = i; H[l] >= j && l >= 1; l --);
			for (r = i + 1; H[r] >= j && r <= n; r ++);
			if (r - l> 1) printf("%d\n", r - l);
		}
	}
}

int main()
{
	freopen("bzoj2251.in", "r", stdin);
	init();
	doit();
	return 0;
}

HDU 3518.Boring counting

题意：给定一个字符串，求有多少个子串出现至少两次，子串不能重叠。

难度：**

如果已经会了后缀数组的一些模型题和上一道题，这道题就变水了，在上一题的基础上，向前向后匹配的时候再多加一个看两个子串是否有重叠的判定就可以了。

CODE：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 10005;

int n, a[MAX_N];
char s[MAX_N];

void init()
{
	n = strlen(s);
	for (int i = 0; i < n; i ++) a[i] = s[i] - 'a', a[i] ++;
	a[n] = 0;
}

int ws[MAX_N], wv[MAX_N], wa[MAX_N], wb[MAX_N];  
int sa[MAX_N], H[MAX_N], R[MAX_N];  
  
void da(int *a, int *sa, int n, int m)   
{  
    int *x = wa, *y = wb;  
    for (int i = 0; i < m; i ++) ws[i] = 0;  
    for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;  
    for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
    for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;  
    for (int k = 1; k <= n; k <<= 1) {  
        int p = 0;  
        for (int i = n - k; i < n; i ++) y[p ++] = i;  
        for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;  
        for (int i = 0; i < n; i ++) wv[i] = x[y[i]];  
        for (int i = 0; i < m; i ++) ws[i] = 0;  
        for (int i = 0; i < n; i ++) ws[wv[i]] ++;  
        for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
        for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];  
        swap(x, y);  
        p = 1; x[sa[0]] = 0;  
        for (int i = 1; i < n; i ++)   
            x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;  
        if (p >= n) break;  
        m = p;   
    }  
}  
  
void calc()  
{  
    for (int i = 1; i <= n; i ++) R[sa[i]] = i;  
    int k = 0, j;  
    for (int i = 0; i < n; H[R[i ++]] = k)  
        for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);  
}  

void doit()
{
	da(a, sa, n + 1, 28);
	calc();
	int cnt = 0;
	for (int i = 1; i <= n; i ++) {
		for (int j = H[i] + 1; sa[i] + j - 1 < n; j ++) {
			int l, r, tmp = 1;
			for (int l = i; H[l] >= j && l >= 1; l --)
				if (H[l] >= j && abs(sa[i] - sa[l - 1]) >= j) tmp ++;
			for (int r = i + 1; H[r] >= j && r <= n; r ++)
				if (H[r] >= j && abs(sa[i] - sa[r]) >= j) tmp ++;
			if (tmp > 1) cnt ++;
		}
	}
	printf("%d\n", cnt);
}

int main()
{
	//freopen("hdu3518.in", "r", stdin);
	while (scanf("%s", s) != EOF) {
		if (s[0] == '#') break;
		init();
		doit();
	}
	return 0;
}

CODEVS 3160.最长公共子串

题意：给两个字符串， 求LCS。

难度：*(模板题)

CODE:

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 200005;

char s[100005];
int n, l1, l2, a[MAX_N];

void init()
{
	n = 0;
	scanf("%s", s);
	l1 = strlen(s);
	for (int i = 0; i < l1; i ++)
		a[n ++] = (int) s[i];
	a[n ++] = 1;
	scanf("%s", s);
	l2 = strlen(s);
	for (int i = 0; i < l2; i ++) 
		a[n ++] = (int) s[i];
	a[n] = 0;
	//for (int i = 0; i < n; i ++) printf("%c", a[i]);
}

int ws[MAX_N], wv[MAX_N], wa[MAX_N], wb[MAX_N];  
int sa[MAX_N], H[MAX_N], R[MAX_N];  
  
void da(int *a, int *sa, int n, int m)   
{  
    int *x = wa, *y = wb;  
    for (int i = 0; i < m; i ++) ws[i] = 0;  
    for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;  
    for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
    for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;  
    for (int k = 1; k <= n; k <<= 1) {  
        int p = 0;  
        for (int i = n - k; i < n; i ++) y[p ++] = i;  
        for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;  
        for (int i = 0; i < n; i ++) wv[i] = x[y[i]];  
        for (int i = 0; i < m; i ++) ws[i] = 0;  
        for (int i = 0; i < n; i ++) ws[wv[i]] ++;  
        for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
        for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];  
        swap(x, y);  
        p = 1; x[sa[0]] = 0;  
        for (int i = 1; i < n; i ++)   
            x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;  
        if (p >= n) break;  
        m = p;   
    }  
}  
  
void calc()  
{  
    for (int i = 1; i <= n; i ++) R[sa[i]] = i;  
    int k = 0, j;  
    for (int i = 0; i < n; H[R[i ++]] = k)  
        for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);  
}  

void doit()
{
	da(a, sa, n + 1, 128);
	calc();
	int ans = 0;
	for (int i = 2; i <= n; i ++) {
		if (H[i] > ans) {
			int t1 = sa[i - 1] > l1, t2 = sa[i] > l1;
			if (t1 ^ t2 == 1) ans = H[i];
		}
	}
	printf("%d\n", ans);
}

int main()
{
	freopen("codevs3160.in", "r", stdin);
	init();
	doit();
	return 0;
}

BZOJ 3238.[AHOI 2013]差异

题意：给定一个字符串，Ti表示以第i个字符为开始的后缀，求所有len(Ti)+len[Tj]-2*LCP(Ti,Tj)之和，其中1<=i<j<=n。

难度：***~****

首先这个式子可以拆成两部分计算，一部分是两个后缀长度之和，一部分是LCP长度之和。第一部分很简单，手推一推就能发现每个长度的后缀都计算了n-1次，所以第一部分的答案为(n-1)*(n*(n+1)/2)，注意计算过程中需要强制类型转换。而第二部分和之前的一个模型类似，需要用到单调栈。两个后缀的LCP在H数组里其实就是一段区间的最小值，而反过来H数组每段区间的最小值就对应着两个后缀的LCP，我们计算总和，不关心都是谁的，所以单调栈维护一个递增的H，用f[i]表示H数组中从i到n所有区间的LCP之和，每次计算f[i]，f[i]=f[st[top]]+H[i]*(st[top]-i)，然后计入总和就行。

CODE:

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAX_N = 500005;
typedef long long ll;

char s[MAX_N];
int a[MAX_N], n;

void init()
{
	scanf("%s", s);
	n = strlen(s);
	for (int i = 0; i < n; i ++) a[i] = (int)s[i];
	a[n] = 0;
}

int ws[MAX_N], wv[MAX_N], wa[MAX_N], wb[MAX_N];  
int sa[MAX_N], H[MAX_N], R[MAX_N];  
  
void da(int *a, int *sa, int n, int m)   
{  
    int *x = wa, *y = wb;  
    for (int i = 0; i < m; i ++) ws[i] = 0;  
    for (int i = 0; i < n; i ++) ws[x[i] = a[i]] ++;  
    for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
    for (int i = n - 1; i >= 0; i --) sa[-- ws[x[i]]] = i;  
    for (int k = 1; k <= n; k <<= 1) {  
        int p = 0;  
        for (int i = n - k; i < n; i ++) y[p ++] = i;  
        for (int i = 0; i < n; i ++) if (sa[i] >= k) y[p ++] = sa[i] - k;  
        for (int i = 0; i < n; i ++) wv[i] = x[y[i]];  
        for (int i = 0; i < m; i ++) ws[i] = 0;  
        for (int i = 0; i < n; i ++) ws[wv[i]] ++;  
        for (int i = 1; i < m; i ++) ws[i] += ws[i - 1];  
        for (int i = n - 1; i >= 0; i --) sa[-- ws[wv[i]]] = y[i];  
        swap(x, y);  
        p = 1; x[sa[0]] = 0;  
        for (int i = 1; i < n; i ++)   
            x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]) ? p - 1 : p ++;  
        if (p >= n) break;  
        m = p;   
    }  
}  
  
void calc()  
{  
    for (int i = 1; i <= n; i ++) R[sa[i]] = i;  
    int k = 0, j;  
    for (int i = 0; i < n; H[R[i ++]] = k)  
        for (k ? k -- : 0, j = sa[R[i] - 1]; a[i + k] == a[j + k]; k ++);  
}  

ll ans = 0, f[MAX_N];
int st[MAX_N];

void doit()
{
	da(a, sa, n + 1, 128);
	calc();
	ans = (ll)(n - 1) * (ll)((ll)n * (ll)(n + 1) / 2);
	ll tmp = 0;
	int top = 0;
	st[++ top] = n + 1;
	for (int i = n; i >= 2; i --) {
		while (top && H[st[top]] > H[i]) top --;
		int x = st[top];
		f[i] = 1ll * H[i] * (x - i) + f[x];
		tmp += f[i];
		st[++ top] = i;
	}
	ans -= 2ll * tmp;
	printf("%lld\n", ans);
}

int main()
{
	freopen("bzoj3238.in", "r", stdin);
	init();
	doit();
	return 0;
}


ALXPCUN
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
11.罗穗骞《后缀数组——处理字符串的有力工具》.zip
08-08
罗穗骞《后缀数组——处理字符串的有力工具》(有算法源码和解题源码) IOI2009论文，有源码，简单易懂，方便学习后缀数组的构造和各种应用。 后缀数组是一种优秀的数据结构，在字符串匹配方面有诸多应用。
算法合集之《后缀数组——处理字符串的有力工具》
diaocuiguo2493的博客
04-06 222
后缀数组： sa[i]:表示排名第i个的首字母位置 Rank[i]:第i个数的排名 Height[i]:sa[i]和sa[i-1]的最长公共前缀 suffix(j) 和suffix(k) 的最长公共前缀为height[rank[j]+1], height[rank[j]+2], height[rank[j]+3], … ,height[rank[k]]中的最小值。 ...
后缀数组例题集
usernamezzz的博客
09-29 230
按这位大佬的博客刷的https://blog.csdn.net/tianyuhang123/article/details/54977648 poj-1743 不可重叠最长重复子串 给你一串数字，求它们最长的重复(公差相同)子序列，且两个子序列不相交 我们可以向二分枚举ans长度,如果能找到两个height>=ans,而且通过sa判断两个的间距>=ans,则说明这个答案合适。 ...
后缀数组题集
帅比王的博客
10-17 539
sa[i]：排名为i的后缀起始位置是多少。 rank[i]：从 i 位置起始的后缀在所有后缀中字典序排序后序号，与sa互逆。 lcp[i]：S[sa[i] ,…] 与 S[sa[i+1] , …]的最长公共前缀。 Musical Theme 测试地址 题意简述 给n个数组成的串，求是否有多个“相似”且不重叠的子串的长度大于等于5，两个子串相似当且仅当长度相等且每一位的数字差都相等。 解题思路 本题...
后缀数组习题集
08-07 120
suffix(i)：从第i个字符开始的后缀 sa[i]：后缀数组，“排第几的是谁”，即suffix(sa[i])<suffix(sa[i+1])，1<=i<n。 ra[i]：名次数组，“你排第几”，ra[i]表示的是suffix(i)在所有后缀中从小到大排列的“名次” height[i]：suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也...
后缀数组练习题若干
水
10-13 3637
POJ 1743    不可重叠最长重复子串 二分答案。 即子串的长度，假设为k时。 利用height数组，将排序后的后缀分为若干组。 每组内的height值都不小于k。 然后只需查看组内是否有满足要求的两个不会产生重叠的子串即可。 #include #include #include #include #include #include #include #defin
后缀数组——处理字符串的有力工具.pdf
07-13
后缀数组这个东西真的是神仙操作…… 但是这个比较神仙的东西在网上的讲解一般都仅限于思想而不是代码，而且这个东西开一堆数组，很多初学者写代码的时候很容易发生歧义理解，所以这里给出一个比较详细的讲解。笔者...
后缀数组详解
08-26
非常详细的后缀数组讲解~~~既看既懂
后缀数组——处理字符串的有力工具1
08-03
摘要】后缀数组是处理字符串的有力工具。后缀数组是后缀树的一个非常精巧的替代品，它比后缀树容易编程实现，能够实现后缀树的很多功能而时间复杂度也并不逊色，而且它比后
后缀数组例题，对学习后缀数组有一点帮组
07-11
学习后缀数组有一点帮组，学习了一周的后缀数组，献给正在为ACM奋斗的同学们
后缀数组题目小结
ACM！荣耀之路！
06-10 4940
因为有两次遇到了后缀数组的题目，于是这才下定决心学习了一下后缀数组，虽然对后缀数组并没有说理解得很透彻，但是一些基本得模板还是会用了，起码对付一些一般的后缀数组应该还是没有问题的了 对于后缀数组的原理什么的我就不多说了，毕竟我理解的不算很透，只是说对于模板得出关键的三个数组还算有点使用的心得而已，具体的大家完全可以去看论文，百度可以找到很多，里面也说的很详细，大部分模板都是从那里面来的
后缀数组题目集
我们仍未知道那天所看见的花的名字。
10-02 115
Musical Theme #include <iostream> #include <stdio.h> #include <string.h> #include <stack> #include <queue> #include <map> #include <set> #include <vector> #include <math.h> #include <bitset> #incl
后缀数组总结（题目合集）
常胜将军的博客
08-25 331
1、hdu6704 K-th occurrence（主席树+后缀树组） 题意：给定串s,q个询问(l,r,k)，求子串s[l,r]的第k次出现位置。 分析：好题。考虑后缀树组sa的含义，sa数组将后缀排序之后，前缀最相似的必然放在了一起（相邻），如果sa[x]前后能找到和后缀x的最长公共前缀大于等于区间长度的后缀，那么说明有子串重复，我们在sa数组找到满足情况（lcp(i,x)>=le...
后缀数组--经典题型
weixin_30699955的博客
02-21 105
后缀例题 转自--后缀数组---处理字符串的有力工具 例1 ：最长公共前缀 问题描述：给定一个字符串，询问某两个后缀的最长公共前缀。 算法分析：问题可以转化为：height数组的区间最小值。所以加上一个 RMQ+倍增算法模板。可以O(1)查询。 题目+代码：略。 例2：可重叠最长重复子串 问题描述：给定一个字符串，求最长重复子串，这两个子串可以重...
后缀数组练习题
lb2003
08-21 239
POJ1743 思路 由于可能转调， 现设匹配长度lenlenlen，A[i∼i+len−1]=A[j∼j+len−1]−w(j&gt;i+len−1)A[i\sim i+len-1]=A[j\sim j+len-1]-w(j&gt;i+len-1)A[i∼i+len−1]=A[j∼j+len−1]−w(j>i+len−1)，w就是转调值，但这样并不好处理。 由于是区间加上(...
后缀数组模板及简单的入门题总结
lajiyuan的博客
05-16 1876
后缀数组模板： const int maxn = 1e5+5;//开总串长度 int wa[maxn],wb[maxn],wsf[maxn],wv[maxn],sa[maxn]; int rank[maxn],height[maxn],s[maxn]; char str1[maxn],str2[maxn]; //sa:字典序中排第i位的起始位置在str中第sa[i] sa[1~n]为有效...
后缀数组的学习笔记与例题
雪的期许
09-17 441
【前言】 后缀数组真神奇。   【后缀】 对于一个字符串，定义suffix(i)为以i起点至结尾的子串。例如ababc，suffix(3)=bc   【后缀树】 后缀树容易理解，就是把一个字符串的所有后缀串插入到一个字典树上（字典树不再累赘）。如图为"ababc"的后缀树： 建造这棵树的代价是O(n*n)的空间复杂度，没什么实用性，只是为了更好的理解后缀数组。注意，对于每个分支...
后缀数组练习题bzoj 1031 后缀数组模板题目
蒟蒻的博客
07-27 833
题目戳这里http://www.lydsy.com/JudgeOnline/problem.php?id=1031 这是一道显然的后缀数组模板题目。 这道题我们发现只要求出这几个循环的字符串排列就好了，那么我们显然想到把它扩展2倍，然后求一边rank和SA数组，这样我们得到了需要的前一半rank数组，把它离散一下就是这个循环圈的排列顺序了。 AC代码：#include<cstdio> #inc
kmp算法next计算方法_【数据结构——串】KMP算法——next数组Python的实现方式
最新发布
06-08
KMP算法中的next数组是用来记录模式串中前缀和后缀的最长公共部分的长度的数组。计算next数组的方法如下： 1. 初始化：next[0] = -1，i = 0，j = -1。 2. 进入循环，判断 i 是否小于模式串的长度，若小于则执行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值