[LeetCode] 28. Implement strStr() 解题思路

Implement strStr().

Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

问题：实现 strStr() 函数。即在  haystack 中匹配 needle 字符串。

可以理解为，实际上这道题是在问如何实现 KMP(Knuth–Morris–Pratt) 算法。这是个效率比较高的算法，只需要扫一遍 haystack 就可以得到结果，耗时 O(n) 。在扫之前需要做的是对 needle 字符串预处理，得到 needle 各个前缀字符串[0...i]中 既是真实前缀又是真实后缀的子字符串的最长长度。理解这句话，需要注意的是“既是真实前缀又是真实后缀” 是指在某一 needle前缀而言的。

需要详细理解 KMP 算法，可以参考前一篇文章我所理解的 KMP(Knuth–Morris–Pratt) 算法，或许有帮助。

vector<int> LofPS;

/**
 * 求 s 中所有前缀字符串[0...i]各自的 既是真实前缀又是真实后缀的子字符串最长长度，存于 LofPS[i]。
 *
 * 例如令 len = LofPS[i]，则表示 真实前缀s[0...len-1] 和 真实后缀s[ i-len+1...i ] 相等。
 *
 */
vector<int> computePrefixSuffix(string s){
    
    // LofPS[i] 表示 s[0....i] 部分中，既是真实前缀又是真实后缀的子字符串最长长度。
    vector<int> LofPS(s.size());
    
    if (s.size() == 0) {
        return LofPS;
    }
    
    LofPS[0] = 0;
    
    int len = 0;
    int i = 1;
    
    while (i < s.size()) {
        
        if (s[i] == s[len]) {
            len++;
            LofPS[i] = len;
            i++;
            continue;
        }
                
        if (len != 0) {
            // 利用之前计算的结果。这里是一个需要理解的点。
            // 根据已计算的 LofPS[len-1]部分 真实前缀、真实后缀的相等的最长长度，定位同样匹配 s 前缀但是更短的子字符串。
            len = LofPS[len - 1];
        }else{
            LofPS[i] = 0;
            i++;
        }
    }
    
    return LofPS;
}


int strStr(string haystack, string needle) {
    
    // 计算 needle 中所有前缀字符串[0...idx]各自的真实前缀且是真实后缀的最长长度。
    vector<int> tmp(needle.size());
    LofPS = tmp;
    
    LofPS = computePrefixSuffix(needle);    
    
    int i = 0 ;
    int k = 0;

    while (i < haystack.size() && k < needle.size()) {
        if (haystack[i] == needle[k]) {
            i++;
            k++;
            continue;
        }
        
        if (LofPS[k-1] != 0) {
            k = LofPS[k-1];
            continue;
        }
        
        if (haystack[i] == needle[0]) {
            k = 1;
            i++;
        }else{
            k = 0;
            i++;
        }
    }

    if (k == needle.size()) {
        return i - k;
    }else{
        return -1;
    }
}