Unique Substrings in Wraparound String

题目来源
给一个字符串，问有多少个唯一子串是abcd…zabc…这么一个循环字符串的子串。
我想着从前往后遍历，每次遍历到一个就往前遍历，找是否有同样字符的，有的话减去重复的，代码如下：

class Solution {
public:
    int findSubstringInWraproundString(string p) {
        int n = p.size(), pre = 0, res = 0;
        for (int i=0; i=1 && (p[j]-p[j-1] == 1 || p[j]-p[j-1] == -25); j--, cur++);
            int maxRepeat = 0;
            for (int j=i-1; j>=0; j--) {
                int nextJ = -1;
                if (p[j] == p[i]) {
                    int tmp = 1;
                    for (int k=j; k>=1 && (p[k]-p[k-1] == 1 || p[k]-p[k-1] == -25); k--, tmp++) {
                        if (p[k-1] == p[i])
                            nextJ = k - 1;
                    }
                    maxRepeat = max(maxRepeat, tmp);
                }
                if (nextJ != -1)
                    j = nextJ + 1;
            }
            cur = (cur < maxRepeat) ? 0 : cur - maxRepeat;
            res = pre + cur;
            pre = res;
        }
        return res;
    }
};

时间复杂度是应该是n方，然后超时了。
然后发现实际上我刚才的方法并不是n方，有一些最坏情况超过n方，然后想了想，实际上并不需要每次都算重复字符子串，可以record下来，代码如下：

class Solution {
public:
    int findSubstringInWraproundString(string p) {
        int n = p.size(), pre = 0, res = 0;
        vector maxRepeat(26, 0);
        for (int i=0; i=1 && (p[j]-p[j-1] == 1 || p[j]-p[j-1] == -25); j--, cur++);
            if (cur > maxRepeat[p[i]-'a']) {
                res += pre + cur - maxRepeat[p[i]-'a'];
                maxRepeat[p[i]-'a'] = cur;
            }
        }
        return res;
    }
};

看了看时间排名，看来是有O(n)的方法的。然后发现实际上每次也不需要向前回溯一次，也是可以利用前面的信息的，代码如下，复杂度O(n)：

class Solution {
public:
    int findSubstringInWraproundString(string p) {
        int n = p.size(), pre = 0, res = 0, preChar = 0;
        vector maxRepeat(26, 0);
        for (int i=0; i maxRepeat[p[i]-'a']) {
                res += pre + curChar - maxRepeat[p[i]-'a'];
                maxRepeat[p[i]-'a'] = curChar;
            }
            preChar = curChar;
        }
        return res;
    }
};