学校算法作业 （六）——— 子串

　　哎，这次ACM的题有些复杂，毕竟字符串题还是有不小难度的，我们来看一下题.（评测机没开，没图了，将就着看看吧）

问题描述

现在有一些由英文字符组成的大小写敏感的字符串，
你的任务是找到一个最长的字符串x，
使得对于已经给出的字符串中的任意一个y，x或者是y的子串，
或者x中的字符反序之后得到的新字符串是y的子串。

输入数据

输入的第一行是一个整数t (1 <= t <= 10)，t表示测试数据的数目。
对于每一组测试数据，第一行是一个整数n (1 <= n <= 100)，
表示已经给出n个字符串。接下来n行，每行给出一个长度在1和100之间的字符串。

输出要求

对于每一组测试数据，输出一行，给出题目中要求的字符串x的长度。

输入样例

2
3
ABCD
BCDFF
BRCD
2
rose
orchid

输出样例

2
2

　　考察的属于最长子序列的查找，这道题没什么特别恶心人的地方，暴力就好了。或者优化一下匹配函数。下面我说一下思路。

　　1、找出长度最小的字串。（最长也不会最小的输入字串长）

　　2、反转最短字串

　　3、找出最大相同字串

思路大概就这三步，实现起来，还是有点意思的。

       第一步，可以在输入的时候完成，设置一个min变量；

       第二步，可以写个函数实现，也可以直接调用 strrev （自己查怎么用）；

       第三步，先选定想用的模式匹配函数，（kmp或者Strstr或者其它）然后，用两重for循环控制字符长度以及正反向递减，再嵌入一层循环控制字符串与模式串之间的比较，完事儿。

讲的有点抽象，为了先打一个大的框架，这也是我的编程思维——自顶向下，逐步细化。

      下面贴一下第三步代码，略微讲一下，没啥技巧，纯暴力

 

/**
 * @brief  查找最大子串
 * @note   
 * @param  *Original: 最短的输入字符串
 * @param  ArrayStrSize: 字符串数组大小
 * @retval 字串长度
 * @author 杨文蓁的小迷弟
 */
int SearchMax(char *Original, int ArrayStrSize)
{
    bool flag; //崩坏标志
    int len = strlen(Original);
    char Normal[MAXSIZE];
    char Reversed[MAXSIZE]; //用来存储逆序

    //比较次数
    for (int i = len; i >= 1; i--)
    {
        //从第j处开始取字串
        for (int j = 0; j <= len - i; j++)
        {
            strncpy(Normal, Original + j, i);
            strncpy(Reversed, Original + j, i);
            Normal[i] = '\0';
            Reversed[i] = '\0';
            strrev(Reversed);
            //reverse(Reversed);//备用翻转函数

            flag = 1;

            for (int row = 0; row < ArrayStrSize; row++)
            {
                if (-1 == KMP(ArrayStr[row], Normal) && -1 == KMP(ArrayStr[row], Reversed))
                {
                    flag = 0;
                    break;
                }
            }
            if (flag)
            {
                return i;
            }
        }
    }
    return 0;
}

 

 

      正如我上面所说的，三重for，两重控制strncpy来改变模式串长度及减小的方向，一个控制比较的主串的变化。

if (-1 == KMP(ArrayStr[row], Normal) && -1 == KMP(ArrayStr[row], Reversed))

这里等于-1 是由于我写的kmp匹配失败返回的为-1。匹配成功的话，由于我的最外层for从len-1开始，所以直接就是最长，不成功的话继续匹配。

 

　　最后我贴一下最终的代码

/**
 * @brief  字串
 * @note   strrevn函数只在gcc中可用Linux和cb都是gcc的解释器
 * @author 杨文蓁的小迷弟
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAXSIZE 101

char ArrayStr[MAXSIZE][MAXSIZE];

void GetNext(char *Pattern, int next[]);
int KMP(char *MainString, char *Pattern);
int SearchMax(char *Original, int ArrayStrSize);
void strrevn(char *str1, char *str2);
void reverse(char *str);

int main()
{
    int times;
    int ArrayStrSize;

    scanf("%d", &times);
    int index = 0;
    for (int i = 0; i < times; i++)
    {
        scanf("%d", &ArrayStrSize);
        int min = MAXSIZE;
        for (int j = 0; j < ArrayStrSize; j++)
        {
            scanf("%s", ArrayStr[j]);
            if (min > strlen(ArrayStr[j]))
            {
                min = strlen(ArrayStr[j]);
                index = j;
            }
        }

        printf("%d\n", SearchMax(ArrayStr[index], ArrayStrSize));
    }
    return 0;
}
/**
 * @brief  查找最大子串
 * @note   
 * @param  *Original: 最短的输入字符串
 * @param  ArrayStrSize: 字符串数组大小
 * @retval 字串长度
 */
int SearchMax(char *Original, int ArrayStrSize)
{
    bool flag; //崩坏标志
    int len = strlen(Original);
    char Normal[MAXSIZE];
    char Reversed[MAXSIZE]; //用来存储逆序

    //比较次数
    for (int i = len; i >= 1; i--)
    {
        //从第j处开始取字串
        for (int j = 0; j <= len - i; j++)
        {
            strncpy(Normal, Original + j, i);
            strncpy(Reversed, Original + j, i);
            Normal[i] = '\0';
            Reversed[i] = '\0';
            strrev(Reversed);
            //reverse(Reversed);//备用翻转函数

            flag = 1;

            for (int row = 0; row < ArrayStrSize; row++)
            {
                if (-1 == KMP(ArrayStr[row], Normal) && -1 == KMP(ArrayStr[row], Reversed))
                {
                    flag = 0;
                    break;
                }
            }
            if (flag)
            {
                return i;
            }
        }
    }
    return 0;
}

/**
 * @brief  字符串反转函数
 * @note   备用
 * @param  *str: 要反转的字符串
 * @retval None
 */
void reverse(char *str)
{
    int len = strlen(str);

    for (int i = 0; i < len / 2; i++)
    {
        char temp = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = temp;
    }
}

/**
 * @brief  字符串反转函数（二）
 * @note   这种更像接口函数
 * @param  *str1: 被反转的字符串
 * @param  *str2: 反转后存储的地方
 * @retval None
 */
void strrevn(char *str1, char *str2)
{
    int l;
    int i;

    l = strlen(str1);
    for (i = 0; i < l; i++)
    {
        str2[i] = str1[l - 1 - i];
    }
}

/**
 * @brief  KMP（字串查找）
 * @note   匹配失败返回-1
 * @param  *MainString: 主串
 * @param  *Pattern: 模式串
 * @retval 最长匹配字串的第一次出现的第一个字母的位置
 */
int KMP(char *MainString, char *Pattern)
{
    int next[MAXSIZE] = {0};
    GetNext(Pattern, next);

    int i = 0;
    int j = 0;
    int s_len = strlen(MainString);
    int PatternLen = strlen(Pattern);

    while (i < s_len && j < PatternLen)
    {
        if (j == -1 || MainString[i] == Pattern[j])
        {
            i++;
            j++;
        }
        else
        {
            j = next[j];
        }
    }

    if (j == PatternLen)
    {
        return i - j;
    }

    return -1;
}

/**
 * @brief  生成转跳数组（未优化）
 * @note   不要使用优化版
 * @param  *Pattern: 模式串
 * @param  next[]: 转跳数组
 * @retval None
 */
void GetNext(char *Pattern, int next[])
{
    int PatternLen = strlen(Pattern);
    int i = 0;
    int j = -1;
    next[0] = -1;

    while (i < PatternLen - 1)
    {
        if (j == -1 || Pattern[i] == Pattern[j])
        {
            i++;
            j++;
            next[i] = j;
        }
        else
        {
            j = next[j];
        }
    }
}

 

　　再贴一个Strstr款的

/**
 * @brief  子串(纯调用string库版本）
 * @note   strrevn函数只在gcc中可用Linux和cb都是gcc的解释器
 * @author 杨文蓁的小迷弟
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAXSIZE 101

char ArrayStr[MAXSIZE][MAXSIZE];

void GetNext(char *Pattern, int next[]);
int KMP(char *MainString, char *Pattern);
int SearchMax(char *Original, int ArrayStrSize);
void strrevn(char *str1, char *str2);
void reverse(char *str);

int main()
{
    int times;
    int ArrayStrSize;

    scanf("%d", &times);
    int index = 0;
    for (int i = 0; i < times; i++)
    {
        scanf("%d", &ArrayStrSize);
        int min = MAXSIZE;
        for (int j = 0; j < ArrayStrSize; j++)
        {
            scanf("%s", ArrayStr[j]);
            if (min > strlen(ArrayStr[j]))
            {
                min = strlen(ArrayStr[j]);
                index = j;
            }
        }

        printf("%d\n", SearchMax(ArrayStr[index], ArrayStrSize));
    }
    return 0;
}
/**
 * @brief  查找最大子串
 * @note   
 * @param  *Original: 最短的输入字符串
 * @param  ArrayStrSize: 字符串数组大小
 * @retval 字串长度
 */
int SearchMax(char *Original, int ArrayStrSize)
{
    bool flag; //崩坏标志
    int len = strlen(Original);
    char Normal[MAXSIZE];
    char Reversed[MAXSIZE]; //用来存储逆序

    //比较次数
    for (int i = len; i >= 1; i--)
    {
        //从第j处开始取字串
        for (int j = 0; j <= len - i; j++)
        {
            strncpy(Normal, Original + j, i);
            strncpy(Reversed, Original + j, i);
            Normal[i] = '\0';
            Reversed[i] = '\0';
            strrev(Reversed);
            //reverse(Reversed);//备用翻转函数

            flag = 1;

            for (int row = 0; row < ArrayStrSize; row++)
            {
                if (NULL == strstr(ArrayStr[row], Normal) && NULL == strstr(ArrayStr[row], Reversed))
                {
                    flag = 0;
                    break;
                }
            }
            if (flag)
            {
                return i;
            }
        }
    }
    return 0;
}

　　如果strrev不可用，那自行写一个反转函数。

 

更新日期 2019-10-11

　　拿c++实现了一下，感兴趣的可以看看，用的是c++11的标准，除了功能函数之外，基本用自带函数实现。

#include <iostream>
#include <vector>
#include <String>
#include <algorithm>

class SubString
{
public:
    int SearchMax(std::vector<std::string> StrArray, int Index);
};

int main()
{
    using std::cin;
    using std::cout;
    using std::string;
    using std::vector;

    int times, index = 0;
    int StrArraySize;
    cin >> times;
    for (int i = 0; i < times; ++i)
    {
        vector<string> StrArray;
        cin >> StrArraySize;
        int min = 101;
        for (int j = 0; j < StrArraySize; ++j)
        {
            string InputStrtemp;
            cin >> InputStrtemp;
            StrArray.push_back(InputStrtemp);
            if (min > StrArray[j].size())
            {
                min = StrArray[j].size();
                index = j;
            }
        }
        SubString SUBSTR;
        int result = SUBSTR.SearchMax(StrArray, index);
        cout << result << '\n';
        StrArray.clear();
    }
    return 0;
}

int SubString::SearchMax(std::vector<std::string> StrArray, int Index)
{
    bool Flag = true;
    int StrArrayLen = StrArray.size();
    int MinStrLen = StrArray[Index].size();
    std::string NormalStr, ReverseStr;

    for (int i = MinStrLen; i >= 1; --i)
    {
        for (int j = 0; j <= MinStrLen - i; ++j)
        {
            Flag = true;
            NormalStr = StrArray[Index].substr(j, i);
            ReverseStr = NormalStr;
            reverse(ReverseStr.begin(), ReverseStr.end());

            for (int k = 0; k < StrArrayLen; ++k)
            {
                if (std::string::npos == StrArray[k].find(NormalStr) && std::string::npos == StrArray[k].find(ReverseStr))
                {
                    Flag = false;
                    break;
                }
            }
            if (Flag)
            {
                return i;
            }
        }

    }
    return 0;

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

class SubString
{
public:
    int SearchMax(std::vector<std::string> StrArray, int Index);
};

int main()
{
    using std::cin;
    using std::cout;
    using std::string;
    using std::vector;

    int times, index = 0;
    int StrArraySize;
    cin >> times;
    for (int i = 0; i < times; ++i)
    {
        vector<string> StrArray;
        cin >> StrArraySize;
        int min = 101;
        for (int j = 0; j < StrArraySize; ++j)
        {
            string InputStrtemp;
            cin >> InputStrtemp;
            StrArray.push_back(InputStrtemp);
            if (min > StrArray[j].size())
            {
                min = StrArray[j].size();
                index = j;
            }
        }
        SubString SUBSTR;
        int result = SUBSTR.SearchMax(StrArray, index);
        cout << result << '\n';
        StrArray.clear();
    }
    return 0;
}

int SubString::SearchMax(std::vector<std::string> StrArray, int Index)
{
    bool Flag = true;
    int StrArrayLen = StrArray.size();
    int MinStrLen = StrArray[Index].size();
    std::string NormalStr, ReverseStr;

    for (int i = MinStrLen; i >= 1; --i)
    {
        for (int j = 0; j <= MinStrLen - i; ++j)
        {
            Flag = true;
            NormalStr = StrArray[Index].substr(j, i);
            ReverseStr = NormalStr;
            reverse(ReverseStr.begin(), ReverseStr.end());

            for (int k = 0; k < StrArrayLen; ++k)
            {
                if (std::string::npos == StrArray[k].find(NormalStr) && std::string::npos == StrArray[k].find(ReverseStr))
                {
                    Flag = false;
                    break;
                }
            }
            if (Flag)
            {
                return i;
            }
        }

    }
    return 0;
}

 

算法不易，诸君共勉！