含有所有字符的最短字符串——滑动窗口

代码1：

没用 map

func minWindow(s string, t string) string {
    n := len(s)
    if n < len(t) {
        return ""
    }
    var ns,nt [60]int32
    check := func() bool {
        for i, v := range nt {
            if ns[i] < v {
                return false
            }
        }
        return true
    }
    for _, v := range t {
        nt[v-'A']++
    }
    an := math.MaxInt32
    a := 0
    aa, bb := -1, 0
    for b, v := range s {
        ns[v-'A']++
        if check() {
            for check() {
                ns[s[a]-'A']--
                a++
            }
            if b-a+2 < an {
                aa, bb = a, b
                an = b-a+2
            }
        }
    }
    if aa == -1 {
        return ""
    }
    return s[aa-1:bb+1]
}

代码2：

用 map

可能 map 遍历速度慢的原因，所以导致使用了 map 反而使得运行速度更慢了

而且因为数据测试的比较小，导致虽然使用 map 进行了空间优化，只记录我们需要的字符，依然比代码 1 中的内存占用更大

func minWindow(s string, t string) string {
    ori, cnt := map[byte]int{}, map[byte]int{}
    for i := 0; i < len(t); i++ {
        ori[t[i]]++
    }

    sLen := len(s)
    len := math.MaxInt32
    ansL, ansR := -1, -1

    check := func() bool {
        for k, v := range ori {
            if cnt[k] < v {
                return false
            }
        }
        return true
    }
    for l, r := 0, 0; r < sLen; r++ {
        if r < sLen && ori[s[r]] > 0 {
            cnt[s[r]]++
        }
        for check() && l <= r {
            if (r - l + 1 < len) {
                len = r - l + 1
                ansL, ansR = l, l + len
            }
            if _, ok := ori[s[l]]; ok {
                cnt[s[l]] -= 1
            }
            l++
        }
    }
    if ansL == -1 {
        return ""
    }
    return s[ansL:ansR]
}