Given strings S
and T
, find the minimum (contiguous) substring W
of S
, so that T
is a subsequence of W
.
If there is no such window in S
that covers all characters in T
, return the empty string ""
. If there are multiple such minimum-length windows, return the one with the left-most starting index.
Example 1:
Input: S = "abcdebdde", T = "bde" Output: "bcde" Explanation: "bcde" is the answer because it occurs before "bdde" which has the same length. "deb" is not a smaller window because the elements of T in the window must occur in order.
Note:
- All the strings in the input will only contain lowercase letters.
- The length of
S
will be in the range[1, 20000]
. - The length of
T
will be in the range[1, 100]
.
这道题给了我们两个字符串S和T,让我们找出S的一个长度最短子串W,使得T是W的子序列,如果长度相同,取起始位置靠前的。清楚子串和子序列的区别,那么题意就不难理解,题目中给的例子也很好的解释了题意。我们经过研究可以发现,返回的子串的起始字母和T的起始字母一定相同,这样才能保证最短。那么你肯定会想先试试暴力搜索吧,以S中每个T的起始字母为起点,均开始搜索字符串T,然后维护一个子串长度的最小值。如果是这种思路,那么还是趁早打消念头吧,博主已经替你试过了,OJ不依。原因也不难想,假如S中有大量的连续b,并且如果T也很长的话,这种算法实在是不高效啊。根据博主多年经验,这种玩字符串且还是Hard的题,十有八九都是要用动态规划Dynamic Programming来做的,那么就直接往DP上去想吧。DP的第一步就是设计dp数组,像这种两个字符串的题,一般都是一个二维数组,想想该怎么定义。确定一个子串的两个关键要素是起始位置和长度,那么我们的dp值到底应该是定起始位置还是长度呢?That is a question! 仔细想一想,其实起始位置是长度的基础,因为我们一旦知道了起始位置,那么当前位置减去起始位置,就是长度了,所以我们dp值定为起始位置。那么 dp[i][j] 表示范围S中前i个字符包含范围T中前j个字符的子串的起始位置,注意这里的包含是子序列包含关系。然后就是确定长度了,有时候会使用字符串的原长度,有时候会多加1,看个人习惯吧,这里博主长度多加了个1。
OK,下面就是重中之重啦,求递推式。一般来说,dp[i][j]的值是依赖于之前已经求出的dp值的,在递归形式的解法中,dp数组也可以看作是记忆数组,从而省去了大量的重复计算,这也是dp解法凌驾于暴力搜索之上的主要原因。牛B的方法总是最难想出来的,dp的递推式就是其中之一。在脑子一片浆糊的情况下,博主的建议是从最简单的例子开始分析,比如 S = "b", T = "b", 那么我们就有 dp[1][1] = 0,因为S中的起始位置为0,长度为1的子串可以包含T。如果当 S = "d", T = "b",那么我们有 dp[1][1] = -1,因为我们的dp数组初始化均为-1,表示未匹配或者无法匹配。下面来看一个稍稍复杂些的例子,S = "dbd", T = "bd",我们的dp数组是:
∅ b d ∅ ? ? ? d ? -1 -1 b ? 1 -1 d ? 1 1
这里的问号是边界,我们还不知道如何初给边界赋值,我们看到,为-1的地方是对应的字母不相等的地方。我们首先要明确的是dp[i][j]中的j不能大于i,因为T的长度不能大于S的长度,所以j大于i的dp[i][j]一定都是-1的。再来看为1的几个位置,首先是 dp[2][1] = 1,这里表示db包含b的子串起始位置为1,make sense!然后是 dp[3][1] = 1,这里表示dbd包含b的子串起始位置为1,没错!然后是 dp[3][2] = 1,这里表示dbd包含bd的起始位置为1,all right! 那么我们可以观察出,当 S[i] == T[j] 的时候,实际上起始位置和 dp[i - 1][j - 1] 是一样的,比如dbd包含bd的起始位置和db包含b的起始位置一样,所以可以继承过来。那么当 S[i] != T[j] 的时候,怎么搞?其实是和 dp[i - 1][j] 是一样的,比如dbd包含b的起始位置和db包含b的起始位置是一样的。
嗯,这就是递推式的核心了,下面再来看边界怎么赋值,由于j比如小于等于i,所以第一行的第二个位置往后一定都是-1,我们只需要给第一列赋值即可。通过前面的分析,我们知道了当 S[i] == T[j] 时,我们取的是左上角的dp值,表示当前字母在S中的位置,由于我们dp数组提前加过1,所以第一列的数只要赋值为当前行数即可。最终的dp数组如下:
∅ b d ∅ 0 -1 -1 d 1 -1 -1 b 2 1 -1 d 3 1 1
为了使代码更加简洁,我们在遍历完每一行,检测如果 dp[i][n] 不为-1,说明T已经被完全包含了,且当前的位置跟起始位置都知道了,我们计算出长度来更新一个全局最小值minLen,同时更新最小值对应的起始位置start,最后取出这个全局最短子串,如果没有找到返回空串即可,参见代码如下:
解法一:
class Solution { public: string minWindow(string S, string T) { int m = S.size(), n = T.size(), start = -1, minLen = INT_MAX; vector<vector<int>> dp(m + 1, vector<int>(n + 1, -1)); for (int i = 0; i <= m; ++i) dp[i][0] = i; for (int i = 1; i <= m; ++i) { for (int j = 1; j <= min(i, n); ++j) { dp[i][j] = (S[i - 1] == T[j - 1]) ? dp[i - 1][j - 1] : dp[i - 1][j]; } if (dp[i][n] != -1) { int len = i - dp[i][n]; if (minLen > len) { minLen = len; start = dp[i][n]; } } } return (start != -1) ? S.substr(start, minLen) : ""; } };
论坛上的danzhutest大神提出了一种双指针的解法,其实这是优化过的暴力搜索的方法,而且居然beat了100%,给跪了好嘛?!而且这双指针的跳跃方式犹如舞蹈般美妙绝伦,比那粗鄙的暴力搜索双指针不知道高到哪里去了?!举个栗子来说吧,比如当 S = "bbbbdde", T = "bde"时,我们知道暴力搜索的双指针在S和T的第一个b匹配上之后,就开始检测S之后的字符能否包含T之后的所有字符,当匹配结束后,S的指针就会跳到第二个b开始匹配,由于有大量的重复b出现,所以每一个b都要遍历一遍,会达到平方级的复杂度,会被OJ无情拒绝。而下面这种修改后的算法会跳过所有重复的b,使得效率大大提升,具体是这么做的,当第一次匹配成功后,我们的双指针往前走,找到那个刚好包含T中字符的位置,比如开始指针 i = 0 时,指向S中的第一个b,指针 j = 0 时指向T中的第一个b,然后开始匹配T,当 i = 6, j = 2 时,此时完全包含了T。暴力搜索解法中此时i会回到1继续找,而这里,我们通过向前再次匹配T,会在 i = 3,j = 0处停下,然后继续向后找,这样S中重复的b就会被跳过,从而达到线性的复杂度。旋转,跳跃,我闭着眼,尘嚣看不见,你沉醉了没?博主已经沉醉在这双指针之舞中了......
解法二:
class Solution { public: string minWindow(string S, string T) { int m = S.size(), n = T.size(), start = -1, minLen = INT_MAX, i = 0, j = 0; while (i < m) { if (S[i] == T[j]) { if (++j == n) { int end = i + 1; while (--j >= 0) { while (S[i--] != T[j]); } ++i; ++j; if (end - i < minLen) { minLen = end - i; start = i; } } } ++i; } return (start != -1) ? S.substr(start, minLen) : ""; } };
类似题目:
Cheapest Flights Within K Stops
Domino and Tromino Tiling
参考资料: