LeetCode - Longest Substring Without Repeating Characters

LeetCode - Longest Substring Without Repeating Characters

2013.12.1 19:50

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.

Solution:

　　Given a string containing only alphabets, find out the length of the longestest substring that contains no repeating characters. Here we display an example:

　　　　abcdeedeeabec

　　The bold part of the string is the target we desire. Here is how my code works:

　　　　1. scan the string from left to right, just once

　　　　2. for every character we encounter, use an array of size 256 to record position of appearance of every character. For example, the character 'b' appears first at position 1(0-based). This helps us detect repeating characters with O(1) time.

　　　　3. Use two pointer $left and $right to record the substring, if the character at $s[$right] causes duplicates, we'll have to move $left forward until the duplicate confict is resolved, explained with an example, too:

　　　　　　abcdeedeeabec -> abcdeedeeabec->abcdeedeeabec

　　　　　　When $right reaches position 5, the character 'e' conflicts with the 'e' at position 4. Then we'll have to move $left beyond position 4 to resolve the conflict.

　　　　4. When the conflict is resolved, continue moving $right forward until it reaches the end.

　　　　5. During the whole process, record the maximum length, that's the answer we need.

　　Time complexity is strictly O(n) with one scan of the array. Space complexity is O(1), requires an array of size 256, that's still O(1), right?

Accepted code:

// 1AC, fast and clear, good work! O(n) complexity
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i, j, len;
        int maxlen;
        
        len = s.length();
        if(len <= 1){
            return len;
        }
        
        // record the emergence of each alphabet
        int a[256];
        
        for(i = 0; i < 256; ++i){
            a[i] = 0;
        }
        
        ++a[s[0]];
        i = 0;
        j = 1;
        maxlen = j - i;
        while(true){
            if(i >= len){
                break;
            }
            while(j < len && a[s[j]] == 0){
                ++a[s[j]];
                ++j;
                if(j - i > maxlen){
                    maxlen = j - i;
                }
            }
            if(j >= len){
                break;
            }
            while(a[s[j]] > 0){
                --a[s[i]];
                ++i;
            }
        }
        return maxlen;
    }
};