最小子串覆盖 · Minimum Window Substring

［抄题］：

给定一个字符串source和一个目标字符串target，在字符串source中找到包括所有目标字符串字母的子串。

在答案的子串中的字母在目标字符串中是否需要具有相同的顺序？

——不需要。

给出source = "ADOBECODEBANC"，target = "ABC" 满足要求的解  "BANC"

 [暴力解法]：

时间分析：

空间分析：

［思维问题］：

原来哈希算法不仅仅是哈希表，int 256数组也可以被称作哈希

［一句话思路］：

boys & girls窗口型两指针

［输入量］：空： 正常情况：特大：特小：程序里处理到的特殊情况：异常情况（不合法不合理的输入）：

［画图］：

［一刷］：

1. targethash 和 sourcehash在此处都是比较一共出现了多少次，而不是对应位置上是否相等。所以0-256所有的字符都要比
2. 存所有的字母c和存数字0-256效果相同

［二刷］：

［三刷］：

［四刷］：

［五刷］：

  [五分钟肉眼debug的结果]：

［关键模板化代码］：

for (i = 0; i < source.length(); i++) {
            //accumulate if not valid
            while(j < source.length() && !valid(sourcehash, targethash)) {
                sourcehash[source.charAt(j)]++;
                j++;
            }
            //change if valid
            if (valid(sourcehash, targethash) && (j - i) < ans) {
                ans = Math.min(ans, j - i);
                minStr = source.substring(i,j);
            }
            //back to i + 1
            sourcehash[source.charAt(i)]--;
        }

［总结］：

结果是两个256哈希数组进行比较，如果字母次数不如target就不符合

［复杂度］：Time complexity: O(2n) Space complexity: O(n)

［英文数据结构或算法，为什么不用别的数据结构或算法］：

［其他解法］：

［Follow Up］：

［LC给出的题目变变变］：

567. Permutation in String 字符串中字母相等：用指针

Substring with Concatenation of All Words 字符串中字母相等：用指针

 [代码风格] ：

.substring 单独一个独立的方法，应该都用小写

public class Solution {
    /**
     * @param source : A string
     * @param target: A string
     * @return: A strindenote the minimum window, return "" if there is no such a string
     */
     void initTargetHash (int[] targethash, String target) {
         for (char ch: target.toCharArray()) {
             targethash[ch]++;
         }
     }
     
     public boolean valid(int[] sourcehash, int[] targethash) {
         for (int i = 0; i < 256; i++) {
             if (sourcehash[i] < targethash[i]) {
                 return false;
             }
         }
         return true;
     }
     
    public String minWindow(String source , String target) {
        //corner case
        String minStr = "";
        if (source.length() < target.length()) {
            return minStr;
        }
        
        int[] sourcehash = new int[256];
        int[] targethash = new int[256];
        int i = 0, j = 0;
        int ans = Integer.MAX_VALUE;
        
        //initialization
        initTargetHash (targethash, target);
        //i,j go in the same direction
        for (i = 0; i < source.length(); i++) {
            //accumulate if not valid
            while(j < source.length() && !valid(sourcehash, targethash)) {
                sourcehash[source.charAt(j)]++;
                j++;
            }
            //change if valid
            if (valid(sourcehash, targethash) && (j - i) < ans) {
                ans = Math.min(ans, j - i);
                minStr = source.substring(i,j);
            }
            //back to i + 1
            sourcehash[source.charAt(i)]--;
        }
        //return
        return minStr;
    }
}