48.【动态规划】最长不含重复字符的子字符串

题目：最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。假设字符串中只包含从’a’到’z’的字符。例如，在字符串中"arabcacfr"，最长非重复子字符串为"acfr"，长度为4。

分析

主要思路：使用动态规划，记录当前字符之前的最长非重复子字符串长度f(i-1)，其中i为当前字符的位置。每次遍历当前字符时，分两种情况：

1）若当前字符第一次出现，则最长非重复子字符串长度f(i) = f(i-1)+1。
2）若当前字符不是第一次出现，则首先计算当前字符与它上次出现位置之间的距离d。

a. 若d大于f(i-1)：即说明前一个非重复子字符串中没有包含当前字符，则可以添加当前字符到前一个非重复子字符串中，所以，f(i) = f(i-1)+1。
b. 若d小于或等于f(i-1)：即说明前一个非重复子字符串中已经包含当前字符，则不可以添加当前字符，所以，f(i) = d。

关键点：动态规划，两个重复字符的距离

public class LongestSingleSubstring {
    public static void main(String[] args) {
        //4
        System.out.println(findLongestSubstringLength("arabcacfr"));
        //1
        System.out.println(findLongestSubstringLength("bbb"));
        //0
        System.out.println(findLongestSubstringLength(""));
    }

    private static int findLongestSubstringLength(String str) {
        if (str == null || str.length() == 0) {
            return 0;
        }
        int maxLength = 0;
        int curLength = 0;
        int[] positions = new int[26];
        // 字符位置初始化为-1，负数表示没出现过
        Arrays.fill(positions, -1);

        for (int i = 0; i < str.length(); i++) {
            int curChar = str.charAt(i) - 'a';
            int prePosition = positions[curChar];
            //当前字符与它上次出现位置之间的距离
            int distance = i - prePosition;
            //当前字符第一次出现，或者前一个非重复子字符串中没有包含当前字符
            if (prePosition < 0 || distance > curLength) {
                curLength++;
            } else {
                //更新最长非重复子字符串的长度
                if (curLength > maxLength) {
                    maxLength = curLength;
                }
                curLength = distance;
            }
            //更新字符出现的位置
            positions[curChar] = i;
        }
        if (curLength > maxLength) {
            maxLength = curLength;
        }
        return maxLength;
    }
}

---

【问题】以上解答为原书中针对只有字母的情况适用；
解法一：

if(s == null||s.length() == 0)
			 return 0;
		 
		 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--;//查找第一个与当前字符相同的位置
			 tmp = tmp < j-i?tmp+1:j-i; 
			 res = Math.max(tmp, res);			 
		 }
		 return res;

解法二（滑动窗口）：

public int lengthOfLongestSubstring(String s) {
        Set<Character> set = new HashSet<Character>();
		int left = 0 ,right = 0, res = 0;
		while(right < s.length()){
			char c = s.charAt(right++);
			while(set.contains(c)){
				set.remove(s.charAt(left++));
			}
			set.add(c);
			res = Math.max(res, right - left);
		}
		return res;
	}