数据结构实验7-串及应用

A. 串应用- 计算一个串的最长的真前后缀

题目描述

给定一个串，如ABCDAB，则 ABCDAB的真前缀有：{ A, AB,ABC, ABCD, ABCDA } ABCDAB的真后缀有：{ B, AB,DAB, CDAB, BCDAB } 因此，该串的真前缀和真后缀中最长的相等串为AB，我们称之为该串的“最长的真前后缀”。 试实现一个函数string matched_Prefix_Postfix(string str)，得到输入串str的最长的真前后缀。若不存在最长的真前后缀则输出empty

输入

第1行：串的个数 n 第2行到第n+1行：n个字符串

输出

n个最长的真前后缀，若不存在最长的真前后缀则输出empty。

输入样例1 <-复制

6
a
ab
abc
abcd
abcda
abcdab

输出样例1

6
a
ab
abc
abcd
abcda
abcdab

#include<iostream>
#include <cstring> 
#include <cstdio>

using namespace std;
string s;

string matched_Prefix_Postfix(string str)
{
	str += '#';//判断一下结束标志
	int next[str.size() + 1];//刚刚加了一个所以长度加一
	next[0] = str.size();//next0存字符串长度
	next[1] = 0;
	int i = 2 , j = 0;//下标从2开始
	while(i <= next[0])
	{
		if(j == 0 || str[i - 2] == str[j - 1])//首先判断当前字符的前面所组成的字符串的前后缀（前一个字符和第一个字符） 
		{
			next[i] = j + 1;//下一个next值需要根据前一个next值来确定，如果前后缀相同则，当前字符的next值为前一个next值+1 
			i ++;
			j = next[i - 1];
		}
		else
		{
			j = next[j];
		} 
	} 
	if(next[str.size()] <= 1)
	{
		return "";
	}
	return str.substr(0,next[str.size()] - 1);//输出最长的真前后缀 
}

int n;

int main()
{
	cin >> n;
	while(n--)
	{
		cin >> s;
		if(matched_Prefix_Postfix(s) != "") 
		cout << matched_Prefix_Postfix(s);
		else
		cout << "empty";
		if(n != 0)
		{
			cout << endl;
		}	
	}
}

 B. DS串应用—最长重复子串

题目描述

求串的最长重复子串长度（子串不重叠）。例如：abcaefabcabc的最长重复子串是串abca，长度为4。

输入

测试次数t

t个测试串

输出

对每个测试串，输出最长重复子串长度，若没有重复子串，输出-1.

输入样例1 <-复制

3
abcaefabcabc
0szu0123szu1
szuabcefg

输出样例1

4
3
-1

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int baoli( string s )
{
	string t1,t2;
	for(int len = s.size() / 2; len > 0; len --)
	{
			for(int i = 0 ; i  < s.size() - len; i ++)
			{
				t1 = s.substr(i,len);
				t2 = s.substr(len+i);
				if(t2.find(t1) != string::npos)
				{
					return len;
				}
			}
	}
	return -1;
}


int main()
{
	int t;
	cin >> t;
	while(t --)
	{
		string s;
		cin >> s;
		cout << baoli(s) << endl;
	}
}

C. 子串循环问题 (Ver. I)

题目描述

给定一个字符串，求需要添加至少几个字符到字符串末尾才能使得整个字符串串由某一个不为本身的子串循环构成？
如"abca"，添加"bc"后构成"abcabc"，其由子串"abc"循环构成;也可以添加"abca"后构成"abcaabca"，其由子串"abca"循环构成，相比之下"bc"只有2个字符，添加的字符量最少。

输入

第一行包括一个整数T(1 <= T <= 100)，代表测试组数

每组测试数据包括一行字符串，其长度范围为 [3, 104]

输出

对于每组测试数据

输出一个整数N，代表添加的最小字符数量

输入样例1 <-复制

5
aaa
abca
abcdefg
abcabcabca
qweaqwec

输出样例1

0
2
7
2
8

大致思路是：

利用KMP算法中的其中一个核心函数Get_next（string a）来算next[a.size()]多少，然后分重叠串和非重叠串进行分类计算

有关子串循环的定理：假设S的长度为len，则S存在最小循环节，循环节的长度L为len-next[len]，子串为S[0…len-next[len]-1]。（1）如果len可以被len - next[len]整除，则表明字符串S可以完全由循环节循环组成，循环周期T=len/L。（2）如果不能，说明还需要再添加几个字母才能补全。需要补的个数是循环个数L-len%L=L-(len-L)%L=L-next[len]%L，L=len-next[len]。
根据上述定理，这里只需要求出next[len]就可以了，所以不需要用KMP里面求next函数的方法，直接针对性的求next[len]。其中用到了字符串截取函数substr()。

#include <iostream>
#include <string>
using namespace std;

int GetNext(string a)
{
    string t1, t2;
    int len = a.length();
    int j = 0;//记录j相等时的最大长度
    for(int i=0; i<len-1; i++)
    {//长度由小到大
        t1 = a.substr(0, i+1);
        t2 = a.substr(len-1-i);
        if(t1==t2 && i+1>j)
            j = i+1;
    }
    return j;
}

int main(void)
{
    int i, n;
    cin>>n;
    for(i=0; i<n; i++)
    {
        string a;
        cin>>a;
        int len = a.length();
        int next_len = GetNext(a);
        int L = len-next_len;
        if(!(len%L) && len!=L)
        //这里要选择L整除len的情况，即len%L==0，但要注意要加个括号再取非，！符的优先级非常高。
        //根据题意，对于循环周期为1的串也需要补（即子串就是本身），所以L==len的情况要归到下面
            cout<<'0'<<endl;
        else
            cout<<L-len%L<<endl;
    }
    return 0;
}

D. DS串应用--串替换

题目描述

给出主串、模式串、替换串，用KMP算法找出模式串在主串的位置，然后用替换串的字符替换掉模式串

本题只考虑一处替换的情况，如果你想做的完美一些，能够实现多处替换那

可能需要考虑模式串和替换串长度不一致的情况

输入

第一个输入t，表示有t个实例

第二行输入第1个实例的主串，第三行输入第1个实例的模式串，第四行输入第1个实例的替换串

以此类推

输出

第一行输出第1个实例的主串

第二行输出第1个实例的主串替换后结果，如果没有发生替换就输出主串原来的内容。

以此类推

输入样例1 <-复制

3
aabbccdd
bb
ff
aaabbbccc
ddd
eee
abcdef
abc
ccccc

输出样例1

aabbccdd
aaffccdd
aaabbbccc
aaabbbccc
abcdef
cccccdef
 

#include <iostream>
#include <string>
using namespace std;

class myString
{
private:
    string mainstr;
    int size;
    void GetNext(string p, int next[]);
    int KMPFind(string p, int pos, int next[]);
public:
    myString();
    ~myString();
    void SetVal(string sp);
    int KMPFindSubstr(string p, int pos);
};

myString::myString()
{
    size = 0;
    mainstr = "";
}

myString::~myString()
{
    size = 0;
    mainstr = "";
}

int myString::KMPFind(string p, int pos, int next[])
{
    int i = pos;
    int j = 0;
    while(i<size && j<(int)p.length())
    {
        if(j==-1 || mainstr[i]==p[j])
        {
            i++;
            j++;
        }
        else
            j = next[j];
    }
    if(j==(int)p.length())
        return i-j;
    else
        return -1;
}

void myString::GetNext(string p, int next[])
{
    int i = 0;
    next[0] = -1;
    int j = -1;
    while(i<(int)p.length())
    {
        if(j==-1 || p[i]==p[j])
        {
            ++i;
            ++j;
            next[i] = j;
        }
        else
            j = next[j];
    }
}

void myString::SetVal(string sp)
{
    mainstr = "";
    mainstr.assign(sp);
    size = mainstr.length();
}

int myString::KMPFindSubstr(string p, int pos)
{
    int i;
    int L = p.length();
    int *next = new int[L];
    GetNext(p, next);
    int v = -1;
    v = KMPFind(p, pos, next);
    delete []next;
    return v;
}

int main(void)
{
    int t;
    cin>>t;
    while(t--)
    {
        myString S;
        string sp;
        string p;
        string str;
        cin>>sp>>p;
        S.SetVal(sp);
        cin>>str;
        cout<<sp<<endl;
        if(S.KMPFindSubstr(p, 0)==-1)
            cout<<sp<<endl;
        else
            cout<<sp.replace(S.KMPFindSubstr(p, 0), p.length(), str)<<endl;
    }
    return 0;
}

E. DS串应用--KMP算法

输入

第一个输入t，表示有t个实例

第二行输入第1个实例的主串，第三行输入第1个实例的模式串

以此类推

输出

第一行输出第1个实例的模式串的next值

第二行输出第1个实例的匹配位置，位置从1开始计算，如果匹配成功输出位置，匹配失败输出0

以此类推

输入样例1 <-复制

3
qwertyuiop
tyu
aabbccdd
ccc
aaaabababac
abac

输出样例1

-1 0 0 
5
-1 0 1 
0
-1 0 0 1 
8
 

#include <iostream>
#include <string>
using namespace std;

class myString{
    string S;
    string T;
    int *next;
    void getNext();
public:
    myString();
    ~myString();
    int KMP();
    void output();
};

myString::myString() {
    cin>>S>>T;
    next = new int[T.size()];
}

myString::~myString() {
    delete []next;
}

int myString::KMP() {
    int i,j;

    for(i=0,j=0;i<S.size() && j<(int)T.size();)
    {
        if(j==-1 || S[i] == T[j])
            i++,j++;
        else
            j = next[j];
    }
    if(j == T.size())
        return i-j+1;
    return 0;
}

void myString::getNext() {
    int i,j;
    i=0,j=-1;
    next[i] = j;
    while (i<T.size())
    {
        if(j==-1 || T[i] == T[j])
            next[++i] = ++j;
        else
            j = next[j];
    }
}

void myString::output() {
    getNext();
    for(int i=0;i<(int)T.size();i++)
        cout<<next[i]<<' ';
    cout<<endl;
    cout<<KMP()<<endl;
}

int main()
{
    int t;
    cin>>t;
    while (t--)
    {
        myString s;
        s.output();
    }
    return 0;
}

F. 可重叠子串 (Ver. I)

题目描述
给定一个字符串（模式串）和一些待查找的字符串，求每个待查找字符串在模式串中出现的次数（可重叠）

输入

第一行输入t，表示有t组测试数据

每一组测试数据包含多行：

每一组的第一行包括一个字符串P，长度不超过105，且非空串

每一组的第二行包括一个整数N，代表待查找的字符串数量 (1 <= N <= 5)

每一组接下来的N行，每一行包括一个待查找的字符串，其长度不超过50，且非空串

输出

对于每组测试数据，

输出每个待查找字符串出现的次数，

具体输出见样例

输入样例

2
aabbcc
3
aa
bb
cc
ababab
1
aba

输出样例

aa:1
bb:1
cc:1
aba:2
 

#include<iostream>
using namespace std;
int main()
{
    string mode,str;
    int num,t,k,i,u,f,j;
    while(cin>>mode) {
        cin >> t;
        while(t--)
        {
            cin>>str;
            string op[100000];
            k=mode.length();
            f=str.length();
            num=0;
            int num1;
            j=0;
            int e=0;
            for(i=0;i<k;i++)
            {
                if(i+f<=k)
                op[e++]=mode.substr(i,f);
            }
            num=0;
            for(i=0;i<e;i++)
            {
                if(op[i]==str)
                    num++;
            }
            cout<<str<<":"<<num<<endl;
        }
    }
}