2019年7月20日 - LeetCode0003
https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/submissions/
我的解法:
1 class Solution { 2 HashSet<Character> set = new HashSet<Character>(); 3 public int lengthOfLongestSubstring(String s) { 4 int len = s.length(); 5 char[] string = new char[len]; 6 s.getChars(0,len,string,0); 7 int ans = 0; 8 //左右边界,左闭右开 9 int left = 0,right = 0; 10 for(int i=0;i<len;++i){ 11 if(set.add(string[i])){ 12 //添加成功,此字符未出现过,右边界扩张1 13 ++right; 14 ans = ans>(right-left)?ans:(right-left); 15 }else{ 16 //添加进集合失败,即出现了重复字符 17 //调整左边界:从右边界现在的位置向后调整 18 for(int j=right-1;j>=left;--j){ 19 if(string[j]==string[i]){ 20 left = j+1; 21 break; 22 } 23 } 24 ++right; 25 ans = ans>(right-left)?ans:(right-left); 26 } 27 } 28 return ans; 29 } 30 }
维护左右边界两个数,然后每次添加进去一个新字符就更新边界,计算长度并与ans比较更新 ans
时间复杂度O(n2),因为最坏情况下每次重复的字符都是在子串的第一个的位置,如"abcdefgabcdefg",那第二个循环必须向前找很远.
空间复杂度O(n),因为用了HashSet可能比手动维护的数组的形式占得空间大一点吧
运行错误一次: 一开始省事儿从第二个字符开始检查,结果忘记了考虑空串,傻了傻了
答案错误一次: 低级错误,不说了太丢脸了(左闭右开算长度减完了我咋还+1了,爆哭)
结果:
官方题解:
方法1:
暴力法,代码略,考察每个子串是否满足无重复字符,会超时的.
方法2:
滑动窗口法.和我这个解法的思路是一样的,仔细想了下为什么我复杂度高然后发现改成这样就会变成O(n)了
我的方法 - 受方法2启发改:
1 class Solution { 2 HashSet<Character> set = new HashSet<Character>(); 3 public int lengthOfLongestSubstring(String s) { 4 int len = s.length(); 5 char[] string = new char[len]; 6 s.getChars(0,len,string,0); 7 int ans = 0; 8 //左右边界,左闭右开 9 int left = 0,right = 0; 10 for(int i=0;i<len;++i){ 11 if(set.add(string[i])){ 12 //添加成功,此字符未出现过,右边界扩张1 13 ++right; 14 ans = ans>(right-left)?ans:(right-left); 15 }else{ 16 //添加进集合失败,即出现了重复字符 17 //调整左边界:从左边界现在的位置向前调整 18 for(int j=left;j<right;++j){ 19 if(string[j]==string[i]){ 20 left = j+1; 21 break; 22 } 23 } 24 ++right; 25 ans = ans>(right-left)?ans:(right-left); 26 } 27 } 28 return ans; 29 } 30 }
这样这个方法时间复杂度就是O(2n) = O(n)的了.空间复杂度O(n)
原因在于这个虽然是两重循环,但是第二重循环每次必定是从新的地方开始,不走回头路.
如: "abcdefgabcdefg",对我的原始方法来说,当检查到第二个a的时候左边界必须向左后退到第一个a,然而下一个检查b,左边界又要向左后退到第一个b,其中[第一个b,第二个a)这些后退都是上一步检查第二个a的时候做过的了,这里在走回头路做无用功,所以浪费了时间.
对改进方法来说,检查第二个a只需要看第一个a,检查第二个b的时候只需要看第一个b,不必走回头路.
即使是对改进方法而言最坏的情况如"abcdefghijklmnnop"来说,即使检查第二个n需要从第一个a一直前进左边界直到第一个n,但是只后再也不会检查这些元素是否在左边界以左了.
体会到了"滑动窗口"这个命名的妙处.比单独的两个边界的名字有整体性.
结果:
方法3:
优化的滑动窗口,利用map而不是set,从根本上省去了第二个循环
受教,学到了的方法:
1 class Solution { 2 HashMap<Character,Integer> map = new HashMap<Character,Integer>(); 3 public int lengthOfLongestSubstring(String s) { 4 int len = s.length(); 5 char[] string = new char[len]; 6 s.getChars(0,len,string,0); 7 int ans = 0; 8 //左右边界,左闭右开 9 int left = 0,right = 0; 10 for(int i=0;i<len;++i){ 11 if(map.containsKey(string[i])){ 12 //找到第一次出现时的位置 13 //左边界不能变小,不能走回头路 14 //在这个前提下把左边界变为上次出现此字符的位置再加一 15 left = map.get(string[i]) + 1>left?map.get(string[i]) + 1:left; 16 } 17 //如果原本就有这个字符,那么这个put是更新此字符的位置,否则是加入一个新的字符并记录它的位置 18 map.put(string[i],i); 19 right = i+1; 20 ans = ans>(right - left)?ans:(right - left); 21 } 22 return ans; 23 } 24 }
left的更新中,left不可以变小很重要.
时间复杂度O(n),空间复杂度O(n)
答案错误一次: 忘记考虑left不可以变小了...
结果:
(诡异的是速度慢于上一个.可能containsKey的开销在数据量比较小的时候真的不能忽略吧)
方法4:
优化的滑动窗口法,不使用HashMap,转而使用一个数组,思路跟上面其实一样,更原始一点所以效率更优一点.
代码略
时间复杂度O(n),空间复杂度O(n)