Day 9 | 28. Find the Index of the First Occurrence in a String | 459. Repeated Substring Pattern

最新推荐文章于 2025-12-06 07:43:37 发布

原创最新推荐文章于 2025-12-06 07:43:37 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

LeetCode 专栏收录该内容

52 篇文章

订阅专栏

这篇博客详细介绍了KMP算法，包括其原理、应用和在LeetCode中的一些实例，如28题和459题。通过构建前缀表实现高效的字符串匹配，并探讨了如何判断字符串是否由重复子串组成。KMP算法在解决字符串匹配问题时能有效避免重复匹配，提高效率。

KMP

KMP was invented by Knuth, Morris and Pratt. So KMP was the abbreviation of the first letters of their names.
KMP is mainly used for string matching. When the string doesn’t match, we can know some parts of the matched text content. Then we can exploit this information to avoid repeat matching.
The prefix table is used for rolling back. It records the position where the pattern string should rematch when the pattern string doesn’t match the text string.

LeetCode 28. Find the Index of the First Occurrence in a String

Question Link

Solution:

class Solution {
    public int strStr(String haystack, String needle) {
        // When needle is null return 0 directly
        if (needle.length() == 0) return 0;
        
        // Construct a next array
        int[] next = new int[needle.length()];
        getNext(next, needle);

        int j = 0;
        for (int i = 0; i < haystack.length(); i++) {
            // Mismatch, roll back
            while (j > 0 && needle.charAt(j) != haystack.charAt(i)) 
                j = next[j - 1];    
            // Match, j and i move backwards at the same time
            if (needle.charAt(j) == haystack.charAt(i)) 
                j++;    // i increases in the loop
            if (j == needle.length())   // neddle in haystack
                return i - needle.length() + 1; 
        }
        return -1;
    }

    // Construct the `next` array is a process that calculates the prefix table
    private void getNext(int[] next, String s) {
        int j = 0;      // point to the end of prefix
        next[0] = j;    // longest equal prefix and suffix lengths

        // i starts from 1, because i point to the end of suffix
        for (int i = 1; i < s.length(); i++) { 
            // The prefix and the suffix are different
            while (j > 0 && s.charAt(j) != s.charAt(i)) 
                j = next[j - 1];    // roll back

            // The prefix and suffix are identical
            if (s.charAt(j) == s.charAt(i)) 
                j++;

            next[i] = j; 
        }
    }
}

Thought：

Construct the next array is a process that calculates the prefix table
i - (needle.length() - 1) is the first position where the pattern string is present in the text string.
In getNext(), i starts from 1, because i points to the start of suffix

LeetCode 459. Repeated Substring Pattern

Question Link

Solution:

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        int len = s.length();
        if(len == 0) 
            return false;
        
        // contruct a next array
        int[] next = new int[len];
        getNext(next, s);

        // Determin whether it is a repeated substring
        if (next[len-1] > 0 && len % (len - next[len-1]) == 0)
            return true;

        return false;
    }

    void getNext(int[] next, String s){
        int j = 0;
        next[0] = j;

        for(int i = 1; i < s.length(); i++){
            while(j > 0 && s.charAt(j) != s.charAt(i))
                j = next[j-1];
            if(s.charAt(j) == s.charAt(i))
                j++;
            next[i] = j;
        }
    }
}

Thoughts:

If a string consists of repeated substrings, the substring that the longest public prefix suffix doesn’t contain is the smallest repeat substring.
The length of array minus the length of longest public prefix suffix is the length of the first cycle. If this cycle’s length could be evenly divisible, it demonstrates that the whole array consist of this cycle.