OJ 1.7 30 字符环

题目

描述

有两个由字符构成的环。请写一个程序，计算这两个字符环上最长连续公共字符串的长度。例如，字符串“ABCEFAGADEGKABUVKLM”的首尾连在一起，构成一个环；字符串“MADJKLUVKL”的首尾连在一起，构成一个另一个环；“UVKLMA”是这两个环的一个连续公共字符串。

输入

一行，包含两个字符串，分别对应一个字符环。这两个字符串之间用单个空格分开。字符串长度不超过255，且不包含空格等空白符。

输出

输出一个整数，表示这两个字符环上最长公共字符串的长度。

样例输入

ABCEFAGADEGKABUVKLM MADJKLUVKL

样例输出

6

思路

扩展字符：字符串首尾相接（strcat），实现类似字符环结构，然后暴力遍历

注意点：

易出现的逻辑错误：
对于输入：

ca caca

会出现结果 4，应该注意到结果是不可能超出原字符串长度的

出现的语法错误：

• strcpy(s1,s1) //错误，前一个变量应当是可写入的，两个变量相同会导致在向前一个变量写入时，后一个变量也发生变化，这样就是一个死循环了
• s1+=s1 //错误，string类型的可以这样写，char类型的不可以

代码

#include <iostream>
#include <cstring> //要使用字符串库函数需要包含此头文件

using namespace std;

int main() {
	char s1[600]; char s2[600]; char s3[600];
	char aa, bb;
	cin >> s1>>s2;
	int n1 = strlen(s1), n2 = strlen(s2);
	int limit = (n1<n2 ? n1:n2);//#include<algorithm>         limit=min(n1,n2)
	n1 *= 2, n2 *= 2;
	strcpy(s3, s1);
	// strcat(s1, s1); 关于strcat，第一个参数所指向的内存地址要求是可写的，当每次向s1写入时，后面的s1也发生了变化
	//不可以s1=s2+s3，s1=s2，string可以
	strcat(s1, s3);
	strcpy(s3, s2);
	strcat(s2, s3);
	

	int i = 0, ii = 0, j = 0, n = 0, res = 0;
	for (i = 0; i < n1; i++)
	{
		ii = i;
		n = 0;//注意break时每次没有回0
		for (j = 0; j < n2; j++)
		{
			if (ii >= n1)  break;
			aa = s1[ii];
			bb = s2[j];
			if (s1[ii] == s2[j])
			{
				n++;
				ii++;
			}
			else
			{				
				n = 0;
				ii = i;
			}
			if (res <= n && n<=limit) res = n;
			if (n >= limit) {
				cout << res;
				return 0;
			}
		}
	}
	cout << res;

	return 0;
}

改进

参考代码1

转自 https://blog.csdn.net/aooubei7175/article/details/101795431

#include<stdio.h>
#include<string.h>
#define MAX(a, b) a > b ? a : b   //定义一个函数，用来比较大小
int main()
{
    char a[256],b[256];
    int i,j,k,lena,lenb,max_len,len;//i用来代表a字符串的起始位置，j代表b字符串；
                                      //lena代a啊字符串长度，lenb代表b字符串的长度；
                                        //len代表相同字符串的长度，max_len代表最大相同的长度；
    int c;
    while(scanf("%s %s",a,b)!=EOF)
    {
        max_len=0;   //初始化最大值
        lena=strlen(a);
        lenb=strlen(b);
        c=MAX(lena,lenb);
        for(i=0;i<lena;i++)
        {                           //用i和j来控制两个字符串开始比较的位置
            for(j=0;j<lenb;j++)
            {
                len=0;
                for(k=0;k<c;k++)    //使两个字符串相比较，并且实现把最长的比较完，最长串完了完以后，最短的也肯定完了，这样可以提高效率，以为之前已有i和j来控制起始的位置，不会出现遗漏 的情况
                {
                   if(a[(i+k)%lena]==b[(j+k)%lenb])//如果字符相同则len++；不相同则开始max_len和len的大小，max——len用来记录最大的长度；比较赋值完后则将len归零，在开始比较下一对字符的比较；直到最长的字符串比较完成。
                   {
                        len++;
                    }
                    else
                    {
                       max_len=MAX(len,max_len);
                        len=0;
                    }
                }
            }
        }
 
        printf("%d\n",max_len);把所有情况比较旺后输出最大相同的长度
    }
    return 0;
}

参考代码2

转自 https://blog.csdn.net/Harington/article/details/86541435

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int main()
{
    int x, y, len, len1, len2, limit, ans=0;
    string s1, s2;
    cin >> s1 >> s2;
    len1 = s1.size();    
    len2 = s2.size();
    limit = min(len1, len2);    //最短字符串的长度
    s1 += s1; // 造环
    s2 += s2; // 造环
    for (int i=0; i<len1; i++){
        for (int j=0; j<len2; j++){
            len = 0;
            x = i;
            y = j;
            while (s1[x++]==s2[y++] && len<limit)     //不能超过段长
                len++;  
            if (len > ans)
                ans = len;
        }
    }
    cout << ans << endl;
    return 0;
}

代码1用的是char，代码2用的是string
具体有以下值得学习的地方

• 对于取2个数的较小值：
  一个方法是 头文件 #include 使用时 min(a，b）
  另一个是 n_min=(a<b?a:b)
• 对于形成字符环结构：
  一个方法是字符串*2
  另一种方法是 （i+k）% len1 利用余数来形成真正的字符环结构
• 字符比较部分的问题：
  我自己的代码对于字符串a进入i次循环，字符b进入j次循环后进行字符比较，并将i值保存，使用变量ii寻址第一个字符串。字符比较相同，则在if结构内将ii、j加1，并更新最大相同字符数量记录值；而在不同时，则在else结构回归原来的i值，清空相同字符数量记录值，并准备剩下b[j]字符串的遍历。但这样的方法比较繁琐，需要注意 何时回归原来的i值、何时清空记录值n
  而代码1时直接进入第三重for循环，将a[i+k]和b[j+k]进行比较，相同时k++，不同时跳出第三重循环
  代码2则是使用while结构，将i、j值赋给新的变量x、y， 利用x、y的自加进行字符是否相同的判断，并在相同时计数

//*******************我的代码
	for (i = 0; i < n1; i++)
	{
		ii = i;
		n = 0;//注意break时每次没有回0
		for (j = 0; j < n2; j++)
		{
			if (ii >= n1)  break;
			aa = s1[ii];
			bb = s2[j];
			if (s1[ii] == s2[j])
			{
				n++;
				ii++;
			}
			else
			{				
				n = 0;
				ii = i;
			}
			if (res <= n && n<=limit) res = n;
			if (n >= limit) {
				cout << res;
				return 0;
			}
		}
	}


//*********************代码1
for(i=0;i<lena;i++)
        {                           //用i和j来控制两个字符串开始比较的位置
            for(j=0;j<lenb;j++)
            {
                len=0;
                for(k=0;k<c;k++)    //使两个字符串相比较，并且实现把最长的比较完，最长串完了完以后，最短的也肯定完了，这样可以提高效率，以为之前已有i和j来控制起始的位置，不会出现遗漏 的情况
                {
                   if(a[(i+k)%lena]==b[(j+k)%lenb])//如果字符相同则len++；不相同则开始max_len和len的大小，max——len用来记录最大的长度；比较赋值完后则将len归零，在开始比较下一对字符的比较；直到最长的字符串比较完成。
                   {
                        len++;
                    }
                    else
                    {
                       max_len=MAX(len,max_len);
                        len=0;
                    }
                }
            }



//************************代码2
    for (int i=0; i<len1; i++){
        for (int j=0; j<len2; j++){
            len = 0;
            x = i;
            y = j;
            while (s1[x++]==s2[y++] && len<limit)     //不能超过段长
                len++;  
            if (len > ans)
                ans = len;
        }
    }