133day（ Longest Substring Without Repeating Characters）

《2018年2月20日》【连续133天】

标题： Longest Substring Without Repeating Characters;

内容：

Given a string, find the length of the longest substring without repeating characters.

给定一个字符串，找到最长的子字符串的长度而不重复字符。

刚开始看题的时候，直接理解错了，以为是求子序列，就按照map的性质写了下面代码：

 public int lengthOfLongestSubstring(String s) {
        HashMap<String,Integer> container =new HashMap<>();
	        for(int i=0;i<s.length(); i++)
	        	container.put(s.substring(i, i+1), i);  //这里是将字符串的每个元素分别放到map中；
	        int result =container.size();
	        return result;
    }

因为key的唯一性，所以轻松的把不相同元素找了出来，并且组合成一个子序列，

 

结果发现原题要的是子字符串，就是在原字符串中是连续的，

接下来我的大体的思路：
1.一开始题目无从下手，就想到分部，把问题分小，由于子串是不固定的，但每个字串必有一终点，

这样，就把问题变成分别以（1~N）为终点，（N为字符串长度），最长无重复字符串长度的最大值；

2.接下来就是求第k个终点上的最长无重复字符串了，可以按照递归，如果知道

以第k-1个为终点的，那么只需把这个字符串拿过来比较就行，具体操作是有第k个元素，依次对比这个字符串从尾到头，

直到发现重复了为止，就把重复之前的拿过来，所以k上的长度在1~(k-1上的长度）+1；

具体代码如下：

class Solution {
    public static StringBuilder length(String s)
	 {
		 int length =s.length(); 
		 char end =s.charAt(length-1); 
		 StringBuilder longest=new StringBuilder("");
		 longest.append(end);  //一开始最长的子字符串就是它本身
		 if(length !=1)
		 {
			 int i;
			 String s1 =s.substring(0, length-1);
			 longest =length(s1);  //求以k-1为终点的最长无重复子字符串
			 for(i=longest.length()-1;i>=0;i--)
			 {
				 if(longest.charAt(i)==end)
				 {
					 if(i!=s1.length())
						{
						 longest =new StringBuilder(longest.substring(i+1, longest.length()));
						 longest.append(end);
						}
					 break;
				 }
				
			 }
			 if(i<0) 
				 longest.append(end);
		 }
		return longest;
	 }
	 public static int lengthOfLongestSubstring(String s) {  //本体
	       int length =s.length();
	       int result =0;  
	       if(length >=2)
	       {   
	    	   String s1="";
		       for(int i=1;i<=length;i++)
		       {
		    	   s1=s.substring(0,i);
		    	   result =Math.max(result,length(s1).length());  
		       }
	       }
	       else 
	    	   result =length;  //考虑到所给字符串为0或1个元素的情况
	       return result;
	 }	        	
}

思路没什么错误，但是超时了，应该是栈堆太多了，如果改成动规的话，就可以避免爆栈了，

 

动规思路不变，具体是采用数组来储存状态；