leetcode(76)最小覆盖子串

最小覆盖子串

第一种方法：

解题思路：滑动串口+双Hash+优化(排除不相关的元素)

class Solution {
    public String minWindow(String s, String t) {
        int slen = s.length();
        int tlen = t.length();
        if(slen==0||tlen==0||tlen>slen){
            return "";
        }
        Map<Character,Integer> map = new HashMap<>();
        Map<Character,Integer> map2 = new HashMap<>();
        List<Character> chars = new ArrayList<Character>();
        List<Integer> ints = new ArrayList<Integer>();
        Integer tt = null;
        Integer ss = null;
        int n=0;
        int start = 0;
        int end = 0;
        int min =slen;
        int minbegin = 0;
        boolean flag=false;
        for(int i=0;i<tlen;i++){
            tt = map.get(t.charAt(i));
            if(tt==null){
                map.put(t.charAt(i),1);
            }else{
                map.put(t.charAt(i),tt+1);
            }
        } 
        for(int i=0;i<slen;i++){
            ss = map.get(s.charAt(i));
            if(map.containsKey(s.charAt(i))){
                chars.add(s.charAt(i));
                ints.add(i);
            }
        }
        slen = chars.size();
        for(int i=0;i<slen;++i){ 
            ss = map.get(chars.get(i));
            if(ss!=null){
                tt = map2.get(chars.get(i));
                if(tt==null){
                    map2.put(chars.get(i),1);
                    ++n;
                }else{
                    if(1+tt<=ss){
                        ++n;
                    }
                    map2.put(chars.get(i),tt+1);
                }
                if(n==tlen){
                    flag=true;
                    end = i;
                    for(int j=start;;++j){
                        ss = map.get(chars.get(j));
                        if(ss!=null){
                            tt = map2.get(chars.get(j));
                            map2.put(chars.get(j),tt-1);
                            if(tt.equals(ss)){
                                start = j;        
                                --n;
                                break;
                            }
                        }
                    }
                    if(min > ints.get(end)+1-ints.get(start)){
                        min=ints.get(end)+1-ints.get(start);
                        minbegin=ints.get(start);
                    }
                    ++start;
                }
            }
        }
        if(!flag) {
            return "";
        }
        return s.substring(minbegin,minbegin+min);
    }
}

 第二种方法：

解题思路：滑动窗口+双Hash

class Solution {
    public String minWindow(String s, String t) {
        int slen = s.length();
        int tlen = t.length();
        if(slen==0||tlen==0||tlen>slen){
            return "";
        }
        Map<Character,Integer> map = new HashMap<>();
        Map<Character,Integer> map2 = new HashMap<>();
        Integer tt = null;
        Integer ss = null;
        int n=0;
        int start = 0;
        int end = 0;
        int min =slen;
        int minbegin = 0;
        boolean flag=false;
        for(int i=0;i<tlen;i++){
            tt = map.get(t.charAt(i));
            if(tt==null){
                map.put(t.charAt(i),1);
            }else{
                map.put(t.charAt(i),tt+1);
            }
        }
        for(int i=0;i<slen;++i){
            ss = map.get(s.charAt(i));
            if(ss!=null){
                tt=map2.get(s.charAt(i));
                if(tt==null){
                    map2.put(s.charAt(i),1);
                    n++;
                }else{
                    if(1+tt<=ss){ 
                        ++n;
                    }
                    map2.put(s.charAt(i),1+tt);
                }
                if(n==tlen){
                    flag=true;
                    end = i;
                    for(int j=start;;++j){
                        ss = map.get(s.charAt(j));
                        if(ss!=null){
                            tt = map2.get(s.charAt(j));
                            map2.put(s.charAt(j),tt-1);
                            if(tt.equals(ss)){
                                start = j;
                                --n;
                                break;
                            }
                        }
                    }
                    if(min>end+1-start){
                        min = end+1-start;
                        minbegin = start;
                    }
                   ++start;
                }
            }
        }
        if(!flag) {
            return "";
        }
        return s.substring(minbegin,minbegin+min);
    }
}