代码随想录算法训练营第九天|LeetCode151. 翻转字符串里的单词，KamaCoder55. 右旋字符串，LeetCode28. 实现 strStr()，LeetCode459. 重复的子字符串

LeetCode151. 翻转字符串里的单词

题目链接：151. 反转字符串中的单词 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：字符串复杂操作拿捏了！ | LeetCode:151.翻转字符串里的单词_哔哩哔哩_bilibili

思路：这是最复杂的一种题了，需要分为三步：
1.去除字符串里的多余空格 
这里面说的空格包括头尾的空格，以及两个或多个连在一起的空格。
2.翻转整个字符串
3.翻转每个单词
        明确了思路之后，我们需要编写两个函数，第一个是删去多余空格的函数，这个函数采用快慢指针的方式，快指针如果遇到不是空格的，说明到单词了，慢指针如果此时不在字符串头上的话，就需要补一个空格，之后只需要复制快指针的内容到慢指针直到又遇到下一个空格。
        第二个是翻转字符串的函数，这个比较好写，主要是在最后的函数中如何调用，我们需要精准定位每个单词的位置。

代码：

class Solution {
public:
    void removespace(string &s){
        int slow=0;
        for(int fast=0;fast<s.size();fast++){
            if(s[fast]!=' '){//遇到一个单词开始处理
                if(slow!=0){
                    s[slow++]=' ';//如果slow此时不在开头就添加一个空格
                }
                while(fast<s.size()&&s[fast]!=' '){
                    s[slow++]=s[fast++];
                }
            }
        }
        s.resize(slow);
    }
    void reverse(string &s,int begin,int end){
        for(int i=begin,j=end;i<j;i++,j--){
            swap(s[i],s[j]);
        }
    }
    string reverseWords(string s) {
        removespace(s);
        reverse(s,0,s.size()-1);
        int wordstart=0;
        for(int i=0;i<=s.size();i++){
            if(s[i]==' '||i==s.size()){
                reverse(s,wordstart,i-1);
                wordstart=i+1;
            }
        }
        return s;
    }
};

KamaCoder55. 右旋字符串 

题目链接：55. 右旋字符串（第八期模拟笔试）
文章讲解：右旋字符串 | 代码随想录

思路：如果允许申请额外空间，这道题还是很简单的。

代码：

#include<bits/stdc++.h>
using namespace std;
int main(){
    int k;
    string s;
    cin>>k;
    cin>>s;
    string s1(s.size(),' ');
    int j=0;
    for(int i=s.size()-k;i<s.size();i++){
        s1[j++]=s[i];
    }
    for(int i=0;i<s.size()-k;i++){
        s1[j++]=s[i];
    }
    cout<<s1<<endl;
}

思路：如果不允许额外申请空间，其实也很简单，只需要先将整体翻转，再翻转前k个，再翻转之后的即可。

代码：

#include<bits/stdc++.h>
using namespace std;
int main(){
    int k;
    string s;
    cin>>k;
    cin>>s;
    reverse(s.begin(),s.end()); 
    reverse(s.begin(),s.begin()+k); 
    reverse(s.begin()+k,s.end()); 
    cout<<s<<endl;
}

LeetCode28. 实现 strStr()

题目链接：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili

思路：这道题正常的解法可以用两层循环解决，不过为了熟悉kmp算法，这道题我们用kmp算法解决。kmp算法解决分为两个步骤，首先是构建next数组，第二步就是根据next数组进行模式串和文本串的匹配。

代码：

class Solution {
public:
    void createnext(int* next,const string& s){
        //j是前缀尾，i是后缀尾
        int j=0;
        next[0]=j;
        for(int i=1;i<s.size();i++){
            while(j>0&&s[j]!=s[i]){
                j=next[j-1];
            }
            if(s[j]==s[i]){
                j++;
            }
            next[i]=j;
        }
    }
    int strStr(string haystack, string needle) {
        vector<int>next(needle.size());
        createnext(&next[0],needle);
        int j=0;
        for(int i=0;i<haystack.size();i++){
            while(j>0&&needle[j]!=haystack[i]){
                j=next[j-1];
            }
            if(needle[j]==haystack[i]){
                j++;
            }
            if (j == needle.size() ) {
                return (i-needle.size()+1);
            }
        }
        return -1;
    }
};

LeetCode459. 重复的子字符串

题目链接：459. 重复的子字符串 - 力扣（LeetCode）
文章讲解：代码随想录
视频讲解：字符串这么玩，可有点难度！ | LeetCode：459.重复的子字符串_哔哩哔哩_bilibili

思路1：直接暴力解法，外层循环i用于遍历重复的长度，内存循环j用于看从[i,s.size()-1]是否每个都满足s[j]==s[j-i]。

代码：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        for(int i=1;i*2<=s.size();i++){
            if(s.size()%i==0){
                bool match=true;
                for(int j=i;j<s.size();j++){
                    if(s[j]!=s[j-i]){
                        match=false;
                        break;
                    }
                }
                if(match==true){
                    return true;
                }
            }
        }
        return false;
    }
};

思路2：next数组的求法不变，主要是主函数，这个需要搞清楚的是

充分条件：如果字符串s是由重复子串组成，那么 最长相等前后缀不包含的子串 一定是 s的最小重复子串。

必要条件：如果字符串s的最长相等前后缀不包含的子串 是 s最小重复子串，那么 s是由重复子串组成。

在这两点想明白之后代码就很好写了，len - (next[len - 1] + 1)是最长相等前后缀不包含的子串的长度。

如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 最长相等前后缀不包含的子串的长度 整除 ，说明该字符串有重复的子字符串。

代码：

class Solution {
public:
    void getNext (int* next, const string& s){
        next[0] = 0;
        int j = 0;
        for(int i = 1;i < s.size(); i++){
            while(j > 0 && s[i] != s[j]) {
                j = next[j - 1];
            }
            if(s[i] == s[j]) {
                j++;
            }
            next[i] = j;
        }
    }
    bool repeatedSubstringPattern (string s) {
        if (s.size() == 0) {
            return false;
        }
        int next[s.size()];
        getNext(next, s);
        int len = s.size();
        if (next[len - 1] != 0 && len % (len - (next[len - 1] )) == 0) {
            return true;
        }
        return false;
    }
};