【Lintcode】857. Minimum Window Subsequence

题目地址：

https://www.lintcode.com/problem/857/

给定两个字符串$s_1$和$s_2$，求$s_1$中长度最短的子串，使$s_2$是它的子序列，返回该子串。若有若干长度相同的，则返回起始位置最左边的那个。

一个更好理解的序列自动机的方法可以参考https://blog.csdn.net/qq_46105170/article/details/119350139。此处介绍一种动态规划的做法。设$f[i][j]$是$s_1$的长$i$的前缀能匹配的$s_2$的长$j$的前缀最右边的匹配起始位置（找最右边是因为要找到最短的子串。这里下标从$1$开始，以下的$s$的下标也从$1$开始），如果不存在匹配则返回$-1$。则$f[i][0]=i,f[0][.>0]=-1$，这里表示如果要匹配空串的话，直接从当前位置之后开始匹配就好了，当前位置就是最右的，这里主要是要保证$f[.][1]$的递推的正确性；而空串不能与非空串产生匹配。接下来考虑怎么递推。对于$f[i][j]$，如果$s_1[i]\ne s_2[j]$，那么说明无法产生匹配，匹配位置是$f[i-1][j]$；如果$s_1[i]=s_2[j]$，则考虑$s_1[i]$用不用，如果用，那么匹配起始位置就是$f[i-1][j-1]$，如果不用，则是$f[i-1][j]$，取更右边的，则有 f [ i ] [ j ] = max ⁡ { f [ i − 1 ] [ j ] , f [ i − 1 ] [ j − 1 ] } f[i][j]=\max\{f[i-1][j],f[i-1][j-1]\} f[i][j]=max{f[i−1][j],f[i−1][j−1]}。从而： f [ i ] [ j ] = { f [ i − 1 ] [ j ] , s 1 [ i ] ≠ s 2 [ j ] max ⁡ { f [ i − 1 ] [ j ] , f [ i − 1 ] [ j − 1 ] } , s 1 [ i ] = s 2 [ j ] f[i][j]=\begin{cases} f[i-1][j],s_1[i]\ne s_2[j]\\\max\{f[i-1][j],f[i-1][j-1]\}, s_1[i]= s_2[j]\end{cases} f[i][j]={f[i−1][j],s1​[i]​=s2​[j]max{f[i−1][j],f[i−1][j−1]},s1​[i]=s2​[j]​最后只需要看一下$f[i][l_{s_2}]$所有存在的匹配的匹配起点，找到最短的子串。代码如下：

public class Solution {
    /**
     * @param s1: a string
     * @param s2: a string
     * @return: the minimum substring of s1
     */
    public String minWindow(String s1, String s2) {
        // Write your code here
        int n = s1.length(), m = s2.length(), begin = -1, minLen = n + 1;
        
        int[][] f = new int[n + 1][m + 1];
        for (int i = 0; i <= m; i++) {
            f[0][i] = i == 0 ? 0 : -1;
        }
        
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                if (j == 0) {
                    f[i][j] = i;
                } else {
                    f[i][j] = f[i - 1][j];
                    if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                        f[i][j] = Math.max(f[i][j], f[i - 1][j - 1]);
                    }
				}
			}
            
            if (f[i][m] != -1) {
                int len = i - f[i][m];
                if (len < minLen) {
                    minLen = len;
                    begin = f[i][m];
                }
            }
        }
        
        return begin == -1 ? "" : s1.substring(begin, begin + minLen);
    }
}

时空复杂度$O(l_{s_1}{l}_{s_2})$。