无重复字符的最长子串

一、前言

问题来源LeetCode

问题链接：https://leetcode-cn.com/explore/interview/card/bytedance/242/string/1012/

 

二、题目

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

 

三、思路

先观察一下，习惯思维是从左往右查找，对应当前字符最长子串，有一下几种情况：

 

情况一：两个相同的字符中间没有其他相同的字符，启动指标是a（0）。如下图当前点a（3），当前点最长子串是(0,3]为字符串bca

 

情况二：两个相同的字符中间没有其他相同的字符，最长字符是最近相同字符的第一个字符到当前字符，我们搜索是从最后一个相同字符b(1)，b(3)，第一个字符是b(1)。如下图当前点a（4），当前点最长子串是(1,4]为字符串cba

 

情况三，起始指标到当前坐标之间都没有相同的字符，如下图，起始指标是c(2)，最后一个指标是d(6)，对应当前坐标d(6)，最长子串是(2,6]，为字符串bacd

 

现在需要解决的是两个问题1：怎样确定当前坐标上一次出现相同字符坐标位置？2：当前坐标起始坐标怎样确定？

问题一：由于字符范围较小，我们可以用一个数组保存每个字符最近出现的坐标。

问题二：有两个解决方法

方法一：我们将遍历的字母放入到队列中，当出现相同字符，队列弹出直到弹出相同的字符。——对应编码第一种解法

方法二：定义一个变量用于记录我们在从左往右遍历的过程中，相同字符的第一个字符坐标位置。——对应编码第二种解法

 

四、解决方法

暴力法不考虑。提供两种解决方法。

方法一：用的是 《三、思路——问题二方法一》解决方法。

方法二：用的是 《三、思路——问题二方法二》解决方法。

方法二效率很更一点点。时间复杂度都是O(n)。

 

五、闲谈

这个问题我们可以联系到两点：

一：字符串操作，我们首先需要想到的是，用数组映射字符，查找速度是O(1)，本题通过数组映射，字符最近一次在字符串中的位置。

二：当我们在搜索是当前的结果和前面的有关联，我们需要想一下栈和队列，会不会问解题提供意想不到的效果，这里我们方法二用可以用到队列，当然方法一更胜一筹。

 

六、编码实现

//==========================================================================
/**
* @file : 01_LengthOfLongestSubstring.h
* @title: 无重复字符的最长子串
* @purpose : 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
* 
* 示例 1:
* 输入: "abcabcbb"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
*
* 示例 2:
* 输入: "bbbbb"
* 输出: 1
* 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
*
* 示例 3:
* 输入: "pwwkew"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
*
* 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
*
*
* 来源：力扣（LeetCode）
* 链接：https://leetcode-cn.com/explore/interview/card/bytedance/242/string/1012/
* 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/
//==========================================================================
#pragma once
#include <queue>
#include <vector>
#include <iostream>
using namespace std;

#define NAMESPACE_LENGTHOFLONGESTSUBSTRING namespace NAME_LENGTHOFLONGESTSUBSTRING {
#define NAMESPACE_LENGTHOFLONGESTSUBSTRINGEND }

NAMESPACE_LENGTHOFLONGESTSUBSTRING

// 方法一
class Solution_1 
{
public:
	int lengthOfLongestSubstring(string s) 
	{
		if (s.length() < 2)
			return (int)s.length();

		vector<int> charArr(UCHAR_MAX, 0);
		int maxLen = 1;
		queue<char> qu;
		qu.push(s[0]);
		charArr[s[0]] = 1;

		for (int i = 1; i < s.length(); ++i)
		{
			qu.push(s[i]);
			if (charArr[s[i]] == 0)
			{
				charArr[s[i]] = 1;
				maxLen = max(maxLen, (int)qu.size());
			}
			else
			{
				while (!qu.empty())
				{
					char c = qu.front();
					if (c == s[i])
					{			
						qu.pop();
						break;
					}
					else
					{
						charArr[c] = 0;
						qu.pop();
					}
				}
			}
		}

		return maxLen;
	}
};

// 方法二
class Solution_2
{
public:
	int lengthOfLongestSubstring(string s)
	{
		if (s.length() < 2)
			return (int)s.length();

		vector<int> charArr(UCHAR_MAX, -1);  
		int maxLen = 1;
		int starti = 0;
		int midi = 0;
		for (int i = 0; i < s.length(); ++i)
		{
			if (charArr[s[i]] == -1)
			{
				charArr[s[i]] = i;
				maxLen = max(maxLen, i - starti + 1);
			}
			else
			{				
				if (midi <= charArr[s[i]])
				{
					maxLen = max(maxLen, i - starti);
					maxLen = max(maxLen, i - charArr[s[i]]);
					midi = charArr[s[i]];
					starti = charArr[s[i]] + 1;
				}

				charArr[s[i]] = i;
			}
		}

		maxLen = max(maxLen, (int)s.length() - starti);
        
		return maxLen;
	}
};


//
// 测试 用例 START
void test(const char* testName, string s, int expect)
{
	Solution_1 S;
	int len = S.lengthOfLongestSubstring(s);

	// 粗略验证一下
	if (len == expect)
	{
		cout << testName << ", solution passed." << endl;
	}
	else
	{
		cout << testName << ", solution failed. len:" << len << " ,expect:" << expect << endl;
	}
}

// 测试用例
void Test1()
{
	string s = "abcabcbb";
	int expect = 3;

	test("Test1()", s, expect);
}

void Test2()
{
	string s = "bbbbb";
	int expect = 1;

	test("Test2()", s, expect);
}

void Test3()
{
	string s = "pwwkew";
	int expect = 3;

	test("Test3()", s, expect);
}

void Test4()
{
	string s = "abcabcbb";
	int expect = 3;

	test("Test4()", s, expect);
}

void Test5()
{
	string s = "aab";
	int expect = 2;

	test("Test5()", s, expect);
}

void Test6()
{
	string s = "aabaab!bb";
	int expect = 3;

	test("Test6()", s, expect);
}

void Test7()
{
	string s = "cdd";
	int expect = 2;

	test("Test7()", s, expect);
}

void Test8()
{
	string s = "abba";
	int expect = 2;

	test("Test8()", s, expect);
}

void Test9()
{
	string s = "dvdf";
	int expect = 3;

	test("Test9()", s, expect);
}

void Test10()
{
	string s = "alouzxilkaxkufsu";
	int expect = 8;

	test("Test10()", s, expect);
}

NAMESPACE_LENGTHOFLONGESTSUBSTRINGEND
// 测试 用例 END
//

void LengthOfLongestSubstring_Test()
{
#if 1
	NAME_LENGTHOFLONGESTSUBSTRING::Test1();
	NAME_LENGTHOFLONGESTSUBSTRING::Test2();
	NAME_LENGTHOFLONGESTSUBSTRING::Test3();
	NAME_LENGTHOFLONGESTSUBSTRING::Test4();
	NAME_LENGTHOFLONGESTSUBSTRING::Test5();
	NAME_LENGTHOFLONGESTSUBSTRING::Test6();
	NAME_LENGTHOFLONGESTSUBSTRING::Test7();
	NAME_LENGTHOFLONGESTSUBSTRING::Test8();
	NAME_LENGTHOFLONGESTSUBSTRING::Test9();
	NAME_LENGTHOFLONGESTSUBSTRING::Test10();
#endif
    //NAME_LENGTHOFLONGESTSUBSTRING::Test10();
}

执行结果：