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

最新推荐文章于 2024-11-04 12:20:00 发布

王锴KKKKKKyle

最新推荐文章于 2024-11-04 12:20:00 发布

阅读量1k

点赞数

分类专栏： LeetCode 文章标签： leetcode

本文链接：https://blog.csdn.net/kyle313606922/article/details/128337737

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

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.