记录D7-23.5.23

LC剑指58 左旋转字符串

这道题比较简单，主要是以前做过一遍了。以题目的示例1来看s=abcdefg, k=2：

1. 先反转前k个字符串，为bacdefg
2. 将整个字符串进行反转，为gfedcab
3. 然后反转前面的s.size()-n个字符串，为cdefgab
   整体的代码为

class Solution {
public:
    void reverse(string& s,int start, int end){
        for(int i=start, j=end;i<j;i++,j--){
            swap(s[i],s[j]);
        }
    }
    string reverseLeftWords(string s, int n) {
        reverse(s, 0, n-1);
        reverse(s, 0, s.size()-1);
        reverse(s, 0, s.size()-1-n);
        return s;
    }
};

LC28 找出字符串中第一个匹配项的下标

这里学习一下KMP算法，主要看两个博主的博客：labuladong和代码随想录。

pat表示模式串，长度为M。txt表示文本串，长度为N。
字符串匹配可以用暴力的方法，对于出现不匹配的字符，同时回退txt和pat的指针。

// 暴力匹配（伪码）
int search(String pat, String txt) {
    int M = pat.length;
    int N = txt.length;
    for (int i = 0; i <= N - M; i++) {
        int j;
        for (j = 0; j < M; j++) {
            if (pat[j] != txt[i+j])
                break;
        }
        // pat 全都匹配了
        if (j == M) return i;
    }
    // txt 中不存在 pat 子串
    return -1;
}

但是如果字符串中重复的字符比较多，那么txt中根本就不需要回退这么多字符。比如txt="aaacaaab", pat="aaab"。pat中根本没有字符c，也就没必要回退指针i。

KMP算法会花费一些空间来记录一些消息，相当于用空间换时间。

KMP 算法永不回退txt的指针i，不走回头路（不会重复扫描txt），而是借助dp数组中储存的信息把pat移到正确的位置继续匹配，时间复杂度只需 O(N)，用空间换时间，所以我认为它是一种动态规划算法。——labuladong

KMP就是一种有限状态自动机，这东西以前在学编译原理的时候学过，虽然忘了，但是大概的思路还是比较简单的。主要是要构造状态转移图。要确定状态转移的行为，得明确两个变量，一个是当前的匹配状态，另一个是遇到的字符；确定了这两个变量后，就可以知道这个情况下应该转移到哪个状态。

为了描述状态转移图，要定义一个二维的dp数组。
//================分隔符-------------------------------
在代码随想录的文章中，不是用状态机来实现的，是用前缀表的方法。不过我感觉也差不多，都是找到当下一个字符不满足要求时应该回退的状态的位置。前缀表的实现主要要找到最长相等前后缀。具体的可以去看一下视频。

构造前缀表的流程主要分为4部分：

1. 初始化
2. 前后缀不相同情况
3. 前后缀相同情况
4. 更新next表

class Solution {
public:
    void getNext(int* next, const string& s){
        //1.初始化
        int j=0;
        next[0]=0;
        for(int i=1;i<s.size();i++){//i在j后面
            //2.前后缀不同情况
            while(j>0 && s[i]!=s[j]){
                j=next[j-1];//j回退到矛盾前一个的状态
            }
            //3.前后缀相同
            if(s[i]==s[j]){
                j++;
            }
            //4.更新next
            next[i]=j;
        }
    }
    int strStr(string haystack, string needle) {
        if(needle.size()==0){
            return 0;
        }
        int next[needle.size()];
        getNext(next,needle);
        int j=0;//j 指向模式串起始位置，i指向文本串起始位置。
        for(int i=0;i<haystack.size();i++){
            while(j>0 && haystack[i]!=needle[j]){
                j=next[j-1];//如果字符不同项，j要从next数组中寻找下一个匹配的位置。
            }
            if(haystack[i]==needle[j]){
                j++;//字符相同，则同时向后移动
            }
            if(j==needle.size()){
                return i-needle.size()+1;
            }
        }
        return -1;
    }
};

但是KMP好复杂…以后再看吧

看了leetcode上的题解，用双指针尝试一下，比暴力稍微好一点。

class Solution {
public:
    int strStr(string haystack, string needle) {
        int m=haystack.size();
        int n=needle.size();
        for(int i=0,j=0;i<m;i++){
            if(haystack[i]==needle[j]){
                j++;
                if(j==n){
                    return i-n+1;
                }
            }
            else{
                i=i-j;//如果没有匹配上，i指针要回退
                j=0;
            }
        }
        return -1;
    }
};