找到具有其他字符串所有字符的子字符串的最小长度的算法

Question

我有两个字符串：
string1 - hello how are you,
String2 - olo（包括空格）

输出：lo ho（hello ho你是）

lo ho 是唯一包含 string2 的所有字符的子字符串。 任何人都可以为此建议一个好的算法（我只能认为 og 蛮力算法 - O(n^2)。

还应该输出最小长度的字符串（如果有多个选项）。

Answer 1

保留两个指针l 和r，以及一个哈希表M = character -> count 用于string2 中不出现在s[l..r] 中的字符。

初始设置l = 0 和r 以便string1[l..r] 包含string2 的所有字符（如果可能）。你可以通过从 M 中删除字符直到它为空来做到这一点。

然后在每个步骤中将r 加一，然后在保持 M 为空的同时尽可能地增加 l。所有r - l + 1（子字符串s[l..r]的长度）的最小值就是解决方案。

Pythonish 伪代码：

n = len(string1)
M = {}   # let's say M is empty if it contains no positive values
for c in string2:
    M[c]++
l = 0
r = -1
while r + 1 < n and M not empty:
    r++
    M[string1[r]]--
if M not empty: 
    return "no solution"
answer_l, answer_r = l, r
while True:
    while M[string1[l]] < 0:
        M[string1[l]]++
        l++
    if r - l + 1 < answer_r - anwer_l + 1:
        answer_l, answer_r = l, r
    r++
    if r == n:
        break
    M[string1[r]]--
return s[answer_l..answer_r]

如果在执行递增和递减操作时保持正条目的数量，则可以在 O(1) 中实现“为空”检查。

设n 为string1 的长度，m 为string2 的长度。

请注意，l 和 r 只会递增，因此最多有 O(n) 次递增，因此在最后一个外循环中最多执行 O(n) 条指令。

如果M 被实现为一个数组（我假设字母是恒定大小的），你会得到运行时 O(n + m)，这是最优的。如果字母表太大，您可以使用哈希表来获得预期的 O(n + m)。

示例执行：

string1 = "abbabcdbcb"
string2 = "cbb"

# after first loop
M = { 'a': 0, 'b': 2, 'c': 1, 'd': 0 }

# after second loop
l = 0
r = 5
M = { 'a': -2, 'b': -1, 'c': 0, 'd': 0 }

# increment l as much as possible:
l = 2
r = 5
M = { 'a': -1, 'b': 0, 'c': 0, 'd': 0 }

# increment r by one and then l as much as possible
l = 2
r = 6
M = { 'a': -1, 'b': 0, 'c': 0, 'd': -1 }

# increment r by one and then l as much as possible
l = 4
r = 7
M = { 'a': 0, 'b': 0, 'c': 0, 'd': -1 }

# increment r by one and then l as much as possible
l = 4
r = 8
M = { 'a': 0, 'b': 0, 'c': -1, 'd': -1 }

# increment r by one and then l as much as possible
l = 7
r = 9
M = { 'a': 0, 'b': 0, 'c': 0, 'd': 0 }

最好的解决方案是 s[7..9]。

Answer 2

我会从string1 中的string2 计算字符的位置，然后选择最低和最高字符位置之间距离最小的排列：

#          positions are:
#          01234567890123456
string1 = 'hello how are you'
string2 = 'olo'

# get string1 positions for each character from set(string2)
positions = {'o': [4, 7, 15],
             'l': [2, 3]}

# get all permutations of positions (don't repeat the same element)
# then pick the permutation with minimum distance between min and max position
# (obviously, this part can be optimized, this is just an illustration)
permutations = positions['o'] * positions['l'] * positions['o']
permutations = [[4,2,7], [4,3,7], [4,2,15], ...]
the_permutation = [4,3,7]

# voilà
output = string1_without_spaces[3:7]

Answer 3

这是一个使用 JavaScript 实现的示例。逻辑和上面@Aprillion 写的差不多。

演示：http://jsfiddle.net/ZB6vm/4/

var s1 = "hello how are you";
var s2 = "olo";
var left, right;
var min_distance;
var answer = "";

// make permutation recursively
function permutate(ar, arrs, k) {
    // check if the end of recursive call
    if (k == arrs.length) {
        var r = Math.max.apply(Math, ar);
        var l = Math.min.apply(Math, ar);
        var dist = r - l + 1;
        if (dist <= min_distance) {
            min_distance = dist;
            left = l;
            right = r;
        }
        return;
    }
    for (var i in arrs[k]) {
        var v = arrs[k][i];
        if ($.inArray(v, ar) < 0) {
            var ar2 = ar.slice();
            ar2.push(v);
             // recursive call
            permutate(ar2, arrs, k + 1);
        }
    }
}

function solve() {
    var ar = [];   // 1-demension array to store character position
    var arrs = []; // 2-demension array to store character position
    for (var i = 0; i < s2.length; i++) {
        arrs[i] = [];
        var c = s2.charAt(i);
        for (var k = 0; k < s1.length; k++) { // loop by s1
            if (s1.charAt(k) == c) {
                if ($.inArray(k, arrs[i]) < 0) {
                    arrs[i].push(k); // save position found
                }
            }
        }
    }
    // call permutate
    permutate(ar, arrs, 0);
    answer = s1.substring(left, right + 1);
    alert(answer);
}

solve();

希望这会有所帮助。

Answer 4

有这个算法可以在 O(N) 中完成。

想法：有 2 个数组，即。 isRequired[256] 和 isFound[256] 告诉了 S 中每个字符的频率，并在解析字符串 S 时，已经找到的每个字符的频率。另外，保留一个计数器，告诉何时找到有效窗口。一旦找到一个有效的窗口，我们可以将窗口（向右）移动，以保持问题的给定不变量。

C++ 程序：

void findMinWindow(const char *text, const char *pattern, int &start, int &end){
        //Calcuate lengths of text and pattern
        int textLen = strlen(text);
        int patternLen = strlen(pattern);

        // Declare 2 arrays which keep tab of required & found frequency of each char in pattern
        int isRequired[256] ; //Assuming the character set is in ASCII
        int isFound[256];
        int count = 0; //For ascertaining whether a valid window is found

        // Keep a tab of minimum window 
        int minimumWindow = INT_MAX;

        //Prepare the isRequired[] array by parsing the pattern
        for(int i=0;i<patternLen;i++){
            isRequired[pattern[i]]++;
        }

        //Let's start parsing the text now
        // Have 2 pointers: i and j - both starting at 0
        int i=0;
        int j=0;
        //Keep moving j forward, keep i fixed till we get a valid window
        for(c=j;c<textLen;c++){
           //Check if the character read appears in pattern or not
           if(isRequired[text[c]] == 0){
              //This character does not appear in the pattern; skip this
              continue;
           }
           //We have this character in the pattern, lets increment isFound for this char
           isFound[text[c]]++;

           //increment the count if this character satisfies the invariant
           if(isFound[text[c]] <= isRequired[text[c]]){
              count++;
           }

           //Did we find a valid window yet?
           if(count == patternLen){
              //A valid window is found..lets see if we can do better from here on
              //better means: increasing i to reduce window length while maintaining invariant
              while(isRequired[s[i]] == 0 || isFound[s[i]] > isRequired[s[i]]){
                   //Either of the above 2 conditions means we should increment i; however we 
                   // must decrease isFound for this char as well.
                   //Hence do a check again
                   if(isFound[s[i]] > isRequired[s[i]]){
                      isFound[s[i]]--;
                   }
                   i++;
              }

               // Note that after the while loop, the invariant is still maintained
               // Lets check if we did better
               int winLength = j-i+1;
               if(winLength < minimumWindow){
                  //update the references we got
                  begin = i;
                  end = j;
                  //Update new minimum window lenght
                  minimumWindow = winLength;
               }
          } //End of if(count == patternLen)
     } //End of for loop 
}