[每日一道小算法（六十二）] [字符串] 最小覆盖子串

前言：
今天做笔试，遇到一道算法题，在此记录一下吧。

题目描述

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。

示例：

输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”
说明：

如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

解题思路

这道题出现在笔试当中了。这道题其实在leetCode上就有这道题。这道题的思路就是使用滑动窗口来实现。我们使用两个指针，一个用于延伸现有的窗口的right指针，和一个用于收缩窗口的left指针。在任意时刻，只有一个指针运动。

1. 初始，left指针和right指针都指向字符串的第一个元素。
2. 将right指针右移，扩张窗口，直到得到一个可行窗口，即包含T的的全部字母的窗口。
3. 得到可行的窗口后，将left指针逐个右移，若得到的窗口依然可行，则更新最小窗口大小。
4. 若窗口不再可行，则跳转至2。
   5.
   重复以上步骤，直到遍历完全部窗口。返回最小的窗口。
   

代码样例

package LeXin;

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

/**
 * 最小覆盖子串
 * 滑动窗口： left:收缩指针 right: 扩展指针
 */
public class Solution2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext())
        {
            String strA = scanner.nextLine();
            String strB = scanner.nextLine();
            String result = minWindow(strA,strB);
            System.out.println(result);
        }
    }
    public static String minWindow(String s, String t) {
        if(s==null||t==null||s.length()==0||t.length()==0)
        {
            return "";
        }
        Map<Character,Integer> map = new HashMap<Character, Integer>();
        for (int i = 0; i < t.length(); i++) {
            int count = map.getOrDefault(t.charAt(i),0);
            map.put(t.charAt(i),count+1);
        }
        Map<Character,Integer> mapCount = new HashMap<Character, Integer>();
        int size = map.size();
        int left = 0; //收缩指针
        int right = 0;//扩展指针
        int formed = 0;//用于跟踪t中有多少个唯一字符
        //存放{window length,left,right}
        int[] ans = {-1,0,0};
        while(right<s.length())
        {
            char c = s.charAt(right);
            int count = mapCount.getOrDefault(s.charAt(right),0);
            mapCount.put(c,count+1);
            //如果当前添加的字符的频率等于以t表示的期望计数，然后将形成的计数加1。
            if(map.containsKey(c) && mapCount.get(c).intValue() == map.get(c).intValue())
            {
                formed++;
            }
            while (left<=right&& formed==size)
            {
                c = s.charAt(left);
                if(ans[0] == -1 || right-left+1<ans[0])
                {
                    ans[0] = right - left + 1;
                    ans[1] = left;
                    ans[2] = right;
                }
                mapCount.put(c,mapCount.get(c)-1);
                if(map.containsKey(c)&& mapCount.get(c).intValue() < map.get(c).intValue())
                {
                    formed--;
                }
                left++;
            }
            right++;
        }
        return ans[0] == -1?"":s.substring(ans[1], ans[2] + 1);
    }
}