代码随想录第九天，151.翻转字符串里的单词、卡码网：55.右旋转字符串、28. 实现 strStr()、459.重复的子字符串

151.翻转字符串里的单词，这道题细节比较多，没那么简单，需要注意去掉空格和反转时的循环边界的设置，去点空格可以用先全部去掉再每隔一个单词加一个空格的方式来实现，反转单词时注意循环的边界，代码如下：

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

void strReverse(string &s, int start, int end)
{
    for (int i = start, j = end; i < j; i++, j--)
    {
        swap(s[i], s[j]);
    }
}

void removeExtraSpaces(string &s)
{
    int slow = 0;
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] != ' ')
        {
            if (slow != 0)
            {
                s[slow++] = ' ';
            }
            while (i < s.size() && s[i] != ' ')
            {
                s[slow++] = s[i++];
            }
        }
    }
    s.resize(slow);
}

string reverseWords(string s)
{
    removeExtraSpaces(s);
    strReverse(s, 0, s.size() - 1);
    int start = 0;
    for (int i = 0; i <= s.size(); i++)
    {
        if (i == s.size() || s[i] == ' ')
        {
            strReverse(s, start, i - 1);
            start = i + 1;
        }
    }
    return s;
}

int main()
{
    string input = "  the sky   is blue  ";
    string output = reverseWords(input);
    cout << output << endl; // 应输出 "blue is sky the"
    return 0;
}

卡码网：55.右旋转字符串，代码如下：

// 第9天，右转字符串
#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int n = 0;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size();

    reverse(s.begin(), s.end());
    reverse(s.begin(), s.begin() + n); // 注意C++中的reverse是左闭右开区间
    reverse(s.begin() + n, s.end());

    cout << s << endl;
}

28. 实现 strStr(),kmp具体看代码随想录，代码如下：

// 28. 实现 strStr()
// KMP算法，实现起来有点难度，尤其是在计算前缀表的时候，要理解动态更新i和j的原理

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

// 函数：计算 KMP 算法中的部分匹配表（前缀函数）
std::vector<int> computeKMPTable(const std::string &needle)
{
    int m = needle.length();
    std::vector<int> lps(m, 0); // 部分匹配表（最长前缀后缀）
    int len = 0;                // 当前的最长前缀后缀长度
    int i = 1;

    while (i < m)
    {
        if (needle[i] == needle[len])
        {
            len++;
            lps[i] = len;
            i++;
        }
        else
        { // 不匹配
            if (len != 0)
            {
                len = lps[len - 1];
                // 注意：这里不增加 i
            }
            else
            { // len == 0
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

// KMP 算法主函数
int KMP(const std::string &haystack, const std::string &needle)
{
    int n = haystack.length();
    int m = needle.length();
    if (m == 0)
        return 0;

    std::vector<int> lps = computeKMPTable(needle);

    int i = 0; // 主字符串的索引
    int j = 0; // 模式字符串的索引

    while (i < n)
    {
        if (needle[j] == haystack[i])
        {
            i++;
            j++;
        }

        if (j == m)
        {
            return i - j; // 匹配成功，返回起始索引
        }
        else if (i < n && needle[j] != haystack[i])
        { // 不匹配
            if (j != 0)
            {
                j = lps[j - 1];
            }
            else
            {
                i++;
            }
        }
    }

    return -1; // 没有找到匹配
}

int main()
{
    std::string haystack = "sadbutsad";
    std::string needle = "but";

    int result = KMP(haystack, needle);
    std::cout << "First occurrence index: " << result << std::endl;
    return 0;
}

459.重复的子字符串，kmp算法，代码如下：

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

// 计算 KMP 算法中的前缀表
std::vector<int> computeKMPTable(const std::string &s)
{
    int n = s.length();
    std::vector<int> lps(n, 0); // 最长前缀后缀表
    int len = 0;                // 最长相同前缀后缀的长度
    int i = 1;

    while (i < n)
    {
        if (s[i] == s[len])
        {
            len++;
            lps[i] = len;
            i++;
        }
        else
        {
            if (len != 0)
            {
                len = lps[len - 1];
            }
            else
            {
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

// 检查字符串是否可以由其子串重复多次构成
bool isRepeatedSubstringPattern(const std::string &s)
{
    int n = s.length();
    std::vector<int> lps = computeKMPTable(s);
    int len = lps[n - 1]; // 获取最长的相同前缀后缀长度

    // 检查最长相同前缀后缀长度是否非零且是字符串长度的一个因子
    return len != 0 && n % (n - len) == 0; // 重点理解为什么 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。
}

int main()
{
    std::string s = "abab";
    bool result = isRepeatedSubstringPattern(s);
    std::cout << (result ? "True" : "False") << std::endl;
    return 0;
}