最长不含重复字符的子字符串

动态规划，用f(i)表示以i个字符结尾不包含重复子字符串的最长长度，从左向右扫描

1、若第i个字符在之前没出现过，则 f(i) = f(i-1) + 1;

2、若第i个字符在之前出现过，

计算第i个字符距离上次出现之间的距离为d

(a)若d <= f(i-1)，则说明第i个字符上次出现在f(i-1)对应的不重复字符串之内，那么这时候更新 f(i) = d

(b)若d > f(i-1)，则无影响,f(i) = f(i-1) + 1

例如arabcacfr

f(0) =1,  a

f(1) = 2,  ar

f(2) = 2,  ra，因为d=2，f(1)=2，所以上一个a在f(1)之中

f(3) = 3,  rab

f(4) = 4,  rabc

f(5) = 3,  bca，因为d=3，f(1)=4，所以上一个a一定在f(4)中

f(6) = 2,  ac

f(7) = 3,  acf

f(8) = 4,  acfr，因为d=7,f(7)=3,因此上一个r不在f(7)中，f(8) = f(7) + 1

 

 /*
* 题目：最长不含重复字符的子字符串
* 解法：动态规划
* 定义函数f(i)表示以第i个字符结尾的包含当前字符的不含重复字符的子字符串的最长长度
* 如果当前的第i个字符没有出现过，那么f(i)=f(i-1)+1,

 如果已经出现过,

设当前元素与上次出现的距离为d，如果d小于等于
* f(i-1),说明上次出现的字符出现在f(i-1)对应的最长字符串之中，f(i)=d;

如果d大于f(i-1),则f(i)=f(i-1)+1
* */

 #include <stdio.h> 
 #include<string.h>

 int longestSubstringWithoutDuplication(char* str,int len){
          int curLength=1;
          int maxLength=0;
          int d,i;
          // 创建一个长度为26的数组保存每个字符上次出现时在字符串中的下标
          int position[26];
          for( i=0;i<26;i++){
              position[i]=-1;
          }
         //保存第0个字符出现时在字符串中的下标
        position[str[0]-'a']=0;
         for ( i=1;i<len;i++){
             if (position[str[i]-'a']!=-1){
                 //说明此字符已经出现过
                 d=i-position[str[i]-'a'];
                 if (d>curLength){
                     curLength=curLength+1;
                 }else {
                    curLength=d;
                 }
                 position[str[i]-'a']=i;
             }else {
                 //没有有出现过
                 curLength=curLength+1;
                position[str[i]-'a']=i;
            }
            if (curLength>maxLength)
				 maxLength=curLength;
         }
         return maxLength;
     }
  
  int main (void){
  	char a[20];
	gets(a); 
	printf("%d\n",longestSubstringWithoutDuplication(a,strlen(a)));
  	return 0;
  }

 

package demo4.jd;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class test99 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println(lengthOfLongestSubstring(sc.nextLine()));
	}
	

	public static int lengthOfLongestSubstring(String s) {

		if (s == null || s.equals("") ) {
			return 0;
		}
		int[] fn = new int[s.length()];
		fn[0] = 1;

		HashMap<Character, Integer> map = new HashMap<>();
		map.put(s.charAt(0), 0);

		for (int i = 1; i < s.length(); i++) {
			if (!map.containsKey(s.charAt(i))) {
				fn[i] = fn[i - 1] + 1;
				map.put(s.charAt(i), i);
			} else {
				Integer integer = map.get(s.charAt(i));
				if (i - integer > fn[i - 1]) {
					fn[i] = fn[i - 1] + 1;
					map.put(s.charAt(i), i);
				} else {
					fn[i] = i - integer;
					map.put(s.charAt(i), i);
				}
			}
		}
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < fn.length; i++) {
			if (fn[i] > max) {
				max = fn[i];
			}
		}
		return max;

	}

	
}