zoukankan      html  css  js  c++  java
  • [LeetCode] Longest Substring Without Repeating Characters

    Well, there many ways to solve this problem. Let's first look at a naive solution.

    The basic idea is simple. Starting from the first character of the string, we visit the next character sequentially. If no duplicates appear, we count the length and update the maximum length. When we meet a repeated character, we find the position of its previous appearance (denoted as pre) and set the starting position to be pre + 1 and repeat the above process till the ending point has exceeded the length of the string. To implement this algorith, we need a hash table to record the last occurrence of each character we see and two pointers for the starting and ending position.

    The code is as follows.

     1     // Naive implementation using two pointers
     2     int lengthOfLongestSubstring(string s) {
     3         int pos[256];
     4         memset(pos, -1, sizeof(pos));
     5         int start = 0, end = 0, maxlen = 0;
     6         while (end < (int)s.length()) {
     7             if (pos[s[end]] >= 0) {
     8                 maxlen = max(maxlen, end - start);
     9                 start = pos[s[end]] + 1;
    10                 end = start;
    11                 memset(pos, -1, sizeof(pos));
    12             }
    13             else pos[s[end]] = end++;
    14         }
    15         return max(maxlen, end - start);
    16     }

    I hope this code to be self-explanatory enough. In fact, we can see that the record of end is to obtain the length of the current substring. So we may simply use another variable to store the length directly. The code then becomes as follows.

     1     // Naive implementation using one pointer
     2     int lengthOfLongestSubstring(string s) {
     3         int pos[256];
     4         memset(pos, -1, sizeof(pos));
     5         int start = 0, len = 0, maxlen = 0;
     6         while (start < (int)s.length()) {
     7             if (pos[s[start]] >= 0) {
     8                 maxlen = max(maxlen, len);
     9                 start = pos[s[start]] + 1;
    10                 memset(pos, -1, sizeof(pos));
    11                 len = 0;
    12             }
    13             else {
    14                 pos[s[start]] = start++;
    15                 len++;
    16             }
    17         }
    18         return max(maxlen, len);
    19     }

    Both of the above codes have called memset several times and thus take much time. In fact, only the characters after the new starting point (inclusive) need to be reset. So we can further reduce the amout of work. We can use a boolean arary to denote whether the element has been appeared and reset those after the new starting point (inclusive).

    The following code runs much faster!

     1     int lengthOfLongestSubstring(string s) {
     2         bool exist[256] = {false};
     3         int start = 0, end = 0, maxlen = 0;
     4         while (end < (int)s.length()) {
     5             if (exist[s[end]]) {
     6                 maxlen = max(maxlen, end - start);
     7                 while (s[start] != s[end])
     8                     exist[s[start++]] = false;
     9                 start++;
    10                 end++;
    11             }
    12             else exist[s[end++]] = true;
    13         }
    14         return max(maxlen, end - start);
    15     }

    One of my friend suggests the following code. It may be hard to understand for the first time. The trick is that it records the length of the current substring and updates it whenever a duplicate occurred.

     1     int lengthOfLongestSubstring(string s) {
     2         int pos[256];
     3         memset(pos, -1, sizeof(pos));
     4         int len = 0, maxlen = 0;
     5         for (int i = 0; i < s.length(); i++) {
     6             int pre = pos[s[i]];
     7             if (pre == -1 || i - len > pre)
     8                 len++;
     9             else {
    10                 maxlen = max(maxlen, len);
    11                 len = i - pre;
    12             }
    13             pos[s[i]] = i;
    14         }
    15         return max(maxlen, len);
    16     }

    Some nice people posted the following short DP code in the LeetCode discuss. The code is damn cool! Please refer to this link for more explanations.

     1     // Dynamic Programming
     2     int lengthOfLongestSubstring(string s) {
     3         int pos[256];
     4         memset(pos, -1, sizeof(pos));
     5         int start = 0, maxlen = 0;
     6         for (int i = 0; i < s.length(); i++) {
     7             start = max(start, pos[s[i]] + 1);
     8             maxlen = max(maxlen, i - start + 1);
     9             pos[s[i]] = i;
    10         }
    11         return max(maxlen, (int)s.length() - start);
    12     }
  • 相关阅读:
    C++ 字符串与数字之间的转换
    两种常见的模式匹配算法(代码实现)
    C++ string整行读取带空格的字符串
    JavaEE(一)开发环境搭建(JDK+Eclipse+Tomcat+Mysql+Spring)
    25java模拟容器的实现
    24java的StringBuilder类和StringBuffer类
    23java的String类常用方法
    22java的回调&内部类
    21java的抽象类和接口
    20java的组合&IDEA踩坑合集1
  • 原文地址:https://www.cnblogs.com/jcliBlogger/p/4559099.html
Copyright © 2011-2022 走看看