我一开始的想法是创建一个大小为26的int数组，下标为0对应的是‘a'，25对应的是’z'，然后一开始都赋为-1，用一个for循环从头遍历这个字符串，通过char c = s.charAt(i)获得字符，然后c-97，就是它对应的int数组的下标，然后访问这个下标下的元素，如果是-1，那么count++，然后把i赋给这个int数组的这个下标下的元素，如果不是-1，说明前面已经出现过了，然后就把这个下标下的值赋给i，让i从上一次出现的位置的后一个重新开始扫描（这次循环后i会+1所以赋给i的下标上的值而不是下标上的值+1），count归零，数组全部归零，整个期间用max记录count的最大值，最后返回max。
class Solution {
int[] visit = new int[26];
public int lengthOfLongestSubstring(String s) {
renew();
int n = s.length();
int count=0, max=0;
for(int i=0;i<n;i++){
char c = s.charAt(i);
if(c==32)return 1;
if(c<97)continue;
int index = c - 97;
if(visit[index] == -1){
count++;
max = Math.max(max, count);
visit[index] =i;
}else{
i = visit[index];
count=0;
renew();
}
}
return max;
}
public void renew(){
for(int i = 0;i<26;i++){
visit[i] = -1;
}
}
}但是示例里面千奇百怪的字符串，比如这个
这样遇到第3个b的时候会到！上去,最后还是放弃了，看了题解，题解如下：
class Solution {
public int lengthOfLongestSubstring(String s) {
HashSet<Character> occ = new HashSet<Character>();
int n = s.length();
int rk = -1,ans = 0;
for(int i =0;i<n;i++){
if(i != 0){
occ.remove(s.charAt(i-1));
}
while(rk + 1 < n && !occ.contains(s.charAt(rk+1))){
occ.add(s.charAt(rk+1));
rk++;
}
ans = Math.max(ans, rk - i +1);
}
return ans;
}
}题解用的是双指针，左指针先不动，右指针往右移动直到遇见重复的，长度就是右-左，它是用一个HashSet来判断重复，每遍历一个如果set里面没有这个字母，就把这个字母放进set里面，如果有就说明重复了。但是题解中的右指针rk，他并没有拿rk去试探是不是重复，而是拿rk+1去看右指针右边这个是不是重复，所以可以看见字符串的长度不是rk-i而是rk-i+1，并且每次遇到重复rk并不会更新，因为i到rk+1是重复的，说明i+1到rk肯定不是重复的（因为i到rk肯定不是重复的），而且左指针每次移动都要把set里面的上一个左指针的字母删掉，这样可以保证set里面存的都是左指针到右指针之间的字母，没有前面的字母，所以可以看见occ.remove(s.charAt(i-1));发现了重复后进入了下一次循环，所以i要减1，才是删掉了上一个左指针。
还有题解是用动态规划写的：
动态规划+哈希表：
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character, Integer> dic = new HashMap<>();
int res = 0, tmp = 0;
for(int j = 0; j < s.length(); j++) {
int i = dic.getOrDefault(s.charAt(j), -1); // 获取索引 i
dic.put(s.charAt(j), j); // 更新哈希表
tmp = tmp < j - i ? tmp + 1 : j - i; // dp[j - 1] -> dp[j]
res = Math.max(res, tmp); // max(dp[j - 1], dp[j])
}
return res;
}
}
动态规划+线性遍历：
class Solution {
public int lengthOfLongestSubstring(String s) {
int res = 0, tmp = 0;
for(int j = 0; j < s.length(); j++) {
int i = j - 1;
while(i >= 0 && s.charAt(i) != s.charAt(j)) i--; // 线性查找 i
tmp = tmp < j - i ? tmp + 1 : j - i; // dp[j - 1] -> dp[j]
res = Math.max(res, tmp); // max(dp[j - 1], dp[j])
}
return res;
}
}
双指针+哈希表：
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character, Integer> dic = new HashMap<>();
int i = -1, res = 0;
for(int j = 0; j < s.length(); j++) {
if(dic.containsKey(s.charAt(j)))
i = Math.max(i, dic.get(s.charAt(j))); // 更新左指针 i
dic.put(s.charAt(j), j); // 哈希表记录
res = Math.max(res, j - i); // 更新结果
}
return res;
}
}
