Leetcode：395. 至少有K个重复字符的最长子串

题目：
找到给定字符串（由小写字符组成）中的最长子串 T ， 要求 T 中的每一字符出现次数都不少于 k 。输出 T 的长度。
示例 1:
输入:
s = “aaabb”, k = 3

输出:
3

最长子串为 “aaa” ，其中 ‘a’ 重复了 3 次。
示例 2:
输入:
s = “ababbc”, k = 2

输出:
5

最长子串为 “ababb” ，其中 ‘a’ 重复了 2 次， ‘b’ 重复了 3 次。

思路：假定长度为最大值，遍历字符串。判断是否符合条件，符合则返回，不符合则长度-1；
结果：超时，27/28

class Solution {
    public int longestSubstring(String s, int k) {
        int len=s.length();
        int res=0;
        String sub=new String();
        for(int i=len;i>=k;i--){
            for(int j=0;j+i<=len;j++){
                sub=s.substring(j,j+i);
                //check(sub,k),调用函数，参数的形式要对应
                if(check(sub,k)) {
                    res=i;
                    //此处，如不直接返回，则res会被后来的值给覆盖~一个函数逻辑上已经得到结果了就应当返回，不要让变数产生。
                    return res;
                }
            }
        }
        return res;
        }
    
    
    public boolean check(String s,int k){
        
        //character 不是Charactor
        HashMap<Character,Integer> map= new HashMap<>();
        HashSet<Character> set=new HashSet<>();
        int temp=0;
        for(char c:s.toCharArray()){
            //if(map.get(c)==0),判断存不存在不是这样的。。
            //!map.contains(c) 也是可以的
            if(map.get(c)==null){
                map.put(c,1);
                set.add(c);
             
            }
            // if一般要和else搭配的，如未搭配，请确定。。
            //else呢。。
            else{
                temp=map.get(c);
                temp++;
                map.put(c,temp);
                
            } 
           
        }
        
        //迭代器
        //set无get
        //int a?
        for(char a:set){
            if(map.get(a)<k) return false;
        }
        
        return true;
    }
}

leetcode英文上，分治法：

public int longestSubstring(String s, int k) {
    char[] str = s.toCharArray();
    return helper(str,0,s.length(),k);
}
private int helper(char[] str, int start, int end,  int k){
    if (end - start < k) return 0;//substring length shorter than k.
    int[] count = new int [26];
    for (int i = start; i<end; i++) {
        int idx = str[i] - 'a';
        count[idx]++;
    }
    //遍历26个字母
    for (int i=0; i<26; i++) {
        if (count[i] < k && count[i] > 0) { //count[i]=0 => i+'a' does not exist in the string, skip it.
            for (int j = start; j<end; j++) {
            //在有该字母（该字母在整个字符串中的个数小于K大于0）出现的第一个地方设立分割点
                if (str[j] == i+'a') {
                    int left = helper(str, start, j, k);
                    int right = helper(str, j+1, end, k);
                    return Math.max(left, right);
                }
            }
        }
    }
    return end - start;
}

leetcode，1ms,beat100%

public int longestSubstring(String s, int k) {
    return helper(s.toCharArray(), 0, s.length(), k);
}
public int helper(char[] chs, int left, int right, int k) {
    if(right - left < k) return 0;
    int[] count = new int[26];
    //统计每个字母出现的次数
    for(int i = left; i < right; i++)
        count[chs[i]-'a']++;
    
    //从左到右检查是否该截取的字符串中有字母出现的个数小于k，
    有则：在i 处左边（一个小于K的字母都未出现）进行分割，右边则对j的值进行判断来缩小范围。返回，左边和右边的最大值。
    无则：直接返回最大值。  
    for(int i = left; i < right; i++) {
    
        if(count[chs[i]-'a'] < k) {
            int j = i + 1;
            while(j < right && count[chs[j]-'a'] < k) j++;
            return Math.max(helper(chs, left, i, k), helper(chs, j, right, k));
        }
    }
    return right - left;
}

2019.4.2回顾
发现逻辑有错误：
死循环了，当s被切分为类似“a”时，死循环。要在
if(s==null)return 0;
下面加上
if(s.length()<k)return 0;

class Solution {
    public int longestSubstring(String s, int k) {
        if(s==null)return 0;
        int []cnum=new int[25];
        char [] c_array=s.toCharArray();
        for(char c:c_array){
            cnum[c-'a']++;
        }
        
        for(int i=0;i<c_array.length;i++){
            char c=c_array[i];
            if(cnum[c-'a']<k){
                //  int re1=longestSubstring(s.substring(0,i), int k); 复制时这个int 
                //Line 14: java.lang.StackOverflowError
                int re1=longestSubstring(s.substring(0,i),  k);
                while(cnum[c-'a']<k&i<c_array.length-1){
                    i++;
                    c=c_array[i];
                }
                int re2=longestSubstring(s.substring(i,c_array.length), k);
                
                return Math.max(re1,re2);
            }
        }
       return s.length();    
    }
}

2019.4.3回顾

 //s.charAt
 //i<r-1
class Solution {
    public int longestSubstring(String s, int k) {
        return helper(s,0,s.length(),k);
    }
    
    public int helper(String s,int l,int r,int k){
        if(r-l<k)return 0;
        int  [] c_array=new int[26];
        for(char c:s.substring(l,r).toCharArray()){
            c_array[c-'a']++;
        }
        
        for(int i=l;i<r;i++){
            //s.charAt
            char c=s.charAt(i);
            if(c_array[c-'a']<k){
                int res1=helper(s,l,i, k);
                //i<r-1
                while(i<r-1&&c_array[c-'a']<k){
                    i++;
                    c=s.charAt(i);
                }
                int res2=helper(s,i,r,k);
                return Math.max(res1,res2);
            }
        }
    return r-l;
    }
}

迭代器
public class TestCollection {
public static void main(String[] args) {
HashSet numbers = new HashSet();

    for (int i = 0; i < 20; i++) {
        numbers.add(i);
    }
     
    //Set不提供get方法来获取指定位置的元素
    //numbers.get(0)
     
    //遍历Set可以采用迭代器iterator
    for (Iterator<Integer> iterator = numbers.iterator(); iterator.hasNext();) {
        Integer i = (Integer) iterator.next();
        System.out.println(i);
    }
     
    //或者采用增强型for循环
    for (Integer i : numbers) {
        System.out.println(i);
    }
     
}

}