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.

题意:

在原串中找到最长的每个字母最多出现一次的字符串

 思路：

  j表示满足条件的字符串的起始位置，i表示结束位置。

i每次往前移动一次，遇到一个新的字符元素，判断当前的集合中是否已经存在这个字母，如果存在，移动j指针，直到排除之前出现过的这个元素。

类似贪心的思想，两个指针维护了以j结束的最长的满足条件的字符串，因此能得到最优解

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
	string s = "jkbakbgkbjkbsb";
	int maxdist = 0;
	int i, j;
	bool sign[26];
	memset(sign, 0, sizeof(sign));
	j = 0;
	for (int i = 0; i < s.length(); i++)
	{
		//先判断是否存在  首先对不存在的字符才能设置成1  如果存在则需要重新设置起始地址j  因为
		//重复字母前面的存在对后面有影响，需要对重复字母前面的进行不存在处理
		if (sign[s[i] - 'a'])//如果存在
		{
			while (sign[s[i] - 'a'])
			{
				sign[s[j] - 'a'] = 0;
				j++;
			}
		}

		//下面对不存在的字符进行设置存在  起始位置在j
		sign[s[i] - 'a'] = 1;
		maxdist = max(maxdist, i - j + 1);

	}
	cout << maxdist << endl;
	system("pause");
	return 0;
}

其他算法：

int lengthOfLongestSubstring(string s) {
  int n = s.length();
  int i = 0, j = 0;
  int maxLen = 0;
  bool exist[256] = { false };
  while (j < n) {
    if (exist[s[j]]) {
      maxLen = max(maxLen, j-i);
      while (s[i] != s[j]) {
        exist[s[i]] = false;
        i++;
      }
      i++;
      j++;
    } else {
      exist[s[j]] = true;
      j++;
    }
  }
  maxLen = max(maxLen, n-i);
  return maxLen;
}

用一个start和end来记录目前考察的字符串的开头和结尾

用exist[26]来记录目前字符串中出现过的字母

用position[26]来记录出现过的字符串的字母的位置

然后我们往后走一位，然后和exist来比较看这个字母是否已经出现过了。

1 如果出现过了，那么我们把start移动到之前那个字母出现的位置的后一位，end往后移动一位

2 如果没有出现过，那么我们就把end往后移动一位

int lengthOfLongestSubstring(string s) {
     int max = 0, start = 0;
     bool exist[26];
   int position[26];
 
     for(int i = 0; i < 26; i++) {
         exist[i] = false;
         position[i] = 0;
     }
 
     for(int i = 0; i < s.size(); i++) {
         if(exist[s[i] - 'a']) {
            for(int j = start; j <= position[s[i] - 'a']; j++) {
                 exist[s[j] - 'a'] = false;
             }
             start = position[s[i] - 'a'] + 1;
             exist[s[i] - 'a'] = true;
             position[s[i] - 'a'] = i;
         }
         else {
             exist[s[i] - 'a'] = true;
             position[s[i] - 'a'] = i;
             max = max > (i - start + 1) ? max : (i - start + 1);
         }
     }
 
     return max;
 }

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int locs[256];//保存字符上一次出现的位置
        memset(locs, -1, sizeof(locs));

        int idx = -1, max = 0;//idx为当前子串的开始位置-1
        for (int i = 0; i < s.size(); i++)
        {
            if (locs[s[i]] > idx)//如果当前字符出现过，那么当前子串的起始位置为这个字符上一次出现的位置+1
            {
                idx = locs[s[i]];
            }

            if (i - idx > max)
            {
                max = i - idx;
            }

            locs[s[i]] = i;
        }
        return max;
    }
};