LeetCode OJ Implement strStr()

Implement strStr().

Returns a pointer to the first occurrence of needle in haystack, or null if needle is not part of haystack.

http://blog.jobbole.com/52830/

http://www.stoimen.com/blog/2012/04/17/computer-algorithms-boyer-moore-string-search-and-matching/

http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        int i = BoyerMoore(needle, haystack);
        if (i == -1) return NULL;
        else return haystack + i;
    }

    void suffixes(char * pattern, vector<int> & suffixes) {
        suffixes[lengthOfPattern - 1] = lengthOfPattern;
        int g = lengthOfPattern - 1;
        int f;

        for (int i = lengthOfPattern - 2; i >= 0; i--) {
            if (i > g && suffixes[i + lengthOfPattern - 1 - f] < i - g) {
                suffixes[i] = suffixes[i + lengthOfPattern - 1 - f];
            } else {
                if (i < g) {
                    g = i;
                }
                f = i;

                while (g >= 0 && pattern[g] == pattern[g + lengthOfPattern - 1 - f]) {
                    g--;
                }
                suffixes[i] = f - g;
            }
        }
    }

    void findBadCharacters(char * pattern, vector<int> & badCharacters) {

        for (int i = 0; i < lengthOfPattern - 1; i++) {
            badCharacters[pattern[i]] = lengthOfPattern - i - 1;
        }
    }

    void findGoodSuffixes(char * pattern, vector<int> & goodSuffixes) {
        vector<int> suff(lengthOfPattern, 0);

        suffixes(pattern, suff);
        
        for (int i = 0; i < lengthOfPattern; i++) {
            goodSuffixes[i] = lengthOfPattern;
        }

        int j = 0;
        for (int i = lengthOfPattern - 1; i >= 0; i--) {
            if (suff[i] == i + 1) {
                for (; j < lengthOfPattern - i - 1; j++) {
                    if (goodSuffixes[j] == lengthOfPattern) {
                        goodSuffixes[j] = lengthOfPattern - i - 1;
                    }
                }
            }
        }

        for (int i = 0; i <= lengthOfPattern - 2; i++) {
            goodSuffixes[lengthOfPattern - 1 - suff[i]] = lengthOfPattern - i - 1;
        }
    }

    int BoyerMoore(char * pattern, char * text) {
        lengthOfText = strlen(text);
        lengthOfPattern = strlen(pattern);

        // some specil cases
        if (lengthOfPattern == 0 && lengthOfText == 0) return 0;
        if (lengthOfPattern == lengthOfText) {
            for (int i = 0; i < lengthOfText; i++) {
                if (pattern[i] != text[i]) return -1;
            }
            return 0;
        }
        if (lengthOfPattern == 0) return lengthOfText - 1;
        if (lengthOfText == 0) return -1;
        
        goodSuffixes.resize(lengthOfPattern);
        badCharacters.resize(256);

        findGoodSuffixes(pattern, goodSuffixes);
        findBadCharacters(pattern, badCharacters);

        int j = 0;
        while (j <= lengthOfText - lengthOfPattern) {
            int i;
            for (i = lengthOfPattern - 1; i >= 0 && pattern[i] == text[i + j]; i--);
            if (i < 0) {
                return j;  // return the first matching position
                //cout << j << endl;  // output every position that is the head of a matching
                j += goodSuffixes[0];
            } else {
                j += max(goodSuffixes[i], badCharacters[text[i + j]] - lengthOfPattern + i + 1);
            }
        }
        return -1;
    }

private:
    vector<int> goodSuffixes;
    vector<int> badCharacters;
    int lengthOfPattern;
    int lengthOfText;
};