LeetCode Longest Substring Without Repeating Characters

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length();
        if (len < 2) return len;
        char cnt[256];
        memset(cnt, 0, sizeof(cnt));
        
        const char* p = s.c_str();
        const char* q = p + 1;
        const char* end = s.c_str() + len - 1;
        
        int mlen = 1;
        cnt[*p] = 1;
        
        while(q <= end) {
            char ch = *q;
            int clen = q - p + (ch == 0);
            
            if (cnt[ch]) { // the character ch already exist in substr[p,q]
                for(; *p != ch; p++) cnt[*p] = 0;
                p++;
            } else {
                cnt[ch] = 1;
            }
            if (clen > mlen) mlen = clen;
            q++;
        }
        
        return mlen;
    }
};

用[p, q]表示一个子串，cnt[ch]表示在这个子串中字符ch出现的次数，如果q移动到一个新的位置发现该位置上的字符ch对应的cnt[ch]==1，说明字符ch已经在[p, q-1]的子串中出现过，那么符合要求的子串必然不会包括[p, q]因为已经有重复了，那么我们就要让移动到子串中与ch重复的那个字符后面的位置如r（移动的同时要把经过的字符对应的计数清零），那么[r, q]子串中就没有重复了，就又可以继续向后检测了。

第二轮：

Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.size() <= 1) return s.size();
        int len = s.size();
        int start = 0;
        int dict[256] = {0};
        int maxlen = 1;
        for (int i=0; i<len; i++) {
            dict[s[i]]++;
            if (dict[s[i]] > 1) {
                for (; s[i] != s[start]; start++) {
                    dict[s[start]]--;
                }
                dict[s[start++]]--;
            }
            
            if (i - start + 1 > maxlen) {
                maxlen = i - start + 1;
            }
        }
        return maxlen;
    }
};

还是稍有不畅

依然不畅

// 20:09
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> stat(256, 0);
        int len = s.length();
        if (len < 1) return 0;
        int res = 0;
        int pre = -1;
        int pos = 0;
        int maxres = 0;
        while (pos < len) {
            char ch = s[pos];
            stat[ch]++;
            if (stat[ch] > 1) {
                while (s[++pre] != ch) stat[s[pre]]--;
                stat[s[pre]]--;
                res = pos - pre;
            } else {
                res++;
            }
            maxres = max(maxres, res);
            pos++;
        }
        return maxres;
    }
};

看了书，写另一中解法，不过还是不流畅，这题真是。。。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.size();
        if (len < 2) {
            return len;
        }
        int dict[256];
        for (int i=0; i<256; i++) {
            dict[i] = -1;
        }
        int start = 0;
        int maxlen= 1;
        for (int i=0; i<len; i++) {
            if (dict[s[i]] != -1) {
                start = max(dict[s[i]] + 1, start);
            }
            maxlen = max(maxlen, i - start + 1);
            dict[s[i]] = i;
        }
        return maxlen;
    }
};