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++无需创建实例而访问类成员函数
    Why do I get "Value computed is not used" when working with pointers?
    指针数组以及指向字符串的理解
    彻底了解指针数组,数组指针,以及函数指针,以及堆中的分配规则
    结构体(struct) 的 sizeof 大小
    C语言深入学习系列 字节对齐&内存管理
    C语言字节对齐详解
    poj2945
    poj2110
  • 原文地址:https://www.cnblogs.com/jcliBlogger/p/4559099.html
Copyright © 2011-2022 走看看