Binary Search - Hard Level - Question 2

Binary Search - Hard Level - Question 2

Leetcode 727 Minimum Window Subsequence

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.

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].

Analysis:

The first step to think about this question may be how to determine a string is a subsequence of another string? 

We can use the two-pointer method: one is a pointer to the beginning of the first string and the other one is a pointer for the second string (to be matched). Once the second pointer can reach the end of the second string, it means we have found a subsequence in the first string.

The time complexity for this step is O(M*N). But this question is asking for the minimum length for all the valid substrings. If we do the same search staring at each char of string S, the time complexity becomes O(M*M*N), which is too large.

One improvement is to record the indexes of each char.

Once we have the indexes of each char, we just either start with the first char of T, or the last char of T. If we choose to start the last char of T, we will start with the last index of the last char of T in S. Then we can find the second last char of T with a most closest distance (to the last char of T) in S, with a binary search. If we can find the second last char of T in S, then we can move on to the third last one of T, until all are found. In such a greedy way, we can find the shortest substring in S having a subsequence as T ending with the last appearance of the last last char of T in S (there may be more than one the last char of T in S). The time complexity is O(N*logM).

Why does binary search work?

1. all the indexes for each char are sorted;

2. we always want to find the next char with a most closest distance.

To find the global shortest substring, we need to start with each appearance the last char of T in S. So the time complexity is O(number of the last char of T in S * N * logM) ~ O(M*N*logM).

See the code below:

string findShortestStr(string s, string t) {
	int m = s.size(), n = t.size(), start = -1, len = 0;
	vector<vector<int>> ids(26);
	for(int i=0; i<m; ++i) {
		ids[s[i]-'a'].push_back(i);
	}
	for(auto &id : ids[t[n-1]-'a']) {
		int idx = id; 
		bool find = true;
		for(int i=n-2; i>=0; --i) {
			int x = t[i] - 'a';
			int p = lower_bound(ids[x].begin(), ids[x].end(), idx) - ids[x].begin();	
			if(p==0) {
				find = false;
				break;
			}
			idx = ids[x][p - 1];
		}
		if(find) {
			if(len == 0 || len > id - idx + 1) {
				start = idx;
				len = id - idx + 1; 
			}
		}
	}
	return start == -1 ? "" : s.substr(start, len);
}

Note:

There are some other methods to solve this problem, such as dp, or the pure two-pointer method.

Upper Layer