Question

说我们有 string a =“abc” string b =“abcdcabaabccbaa”

查找b中所有排列的位置。我正在努力为此找到一个有效的算法。

伪码：

sort string a // O(a loga)

for windows of length a in b  // O(b)?
   sort that window of b      // O(~a loga)?
   compare to a
   if equal
      save the index

那么这是一个正确的算法吗？运行时间大约是O（aloga + ba loga）〜= O（loga b）？这有多高效？可能是减少到O（a * b）还是更好？

Answer 1

排序非常昂贵，并且没有使用您沿着滑动窗口移动的事实。

我会使用与位置无关的比较方法（因为任何排列都是有效的） - 为每个字母分配一个素数，每个字符串将是其字母值的乘法。

这样，当你越过b时，每一步都需要除以你从左边移开的字母，并乘以下一个字母。

你还需要说服自己，这确实与每个字符串唯一匹配并涵盖所有排列 - 这来自于素数分解的唯一性。另请注意，在较大的字符串上，数字会变大，因此您可能需要一些大数据库

Answer 2

无需哈希，您只需计算滑动窗口上的频率，并检查它是否匹配。假设您的字母大小为s，您将获得非常简单O(s(n + m))算法。

// a = [1 .. m] and b = [1 .. n] are the input
cnta = [1 .. s] array initialized to 0
cntb = [1 .. s] array initialized to 0
// nb_matches = the number of i s.t. cnta[i] = cntb[i]
// thus the current subword = a iff. nb_matches = s
nb_matches = s

for i = 1 to m:
    if cntb[a[i]] = 0: nb_matches -= 1
    cntb[a[i]] += 1

ans = 0
for i = 1 to n:
    if cntb[b[i]] = cnta[b[i]]: nb_matches -= 1
    cntb[b[i]] += 1
    if nb_matches = s: ans += 1
    if cntb[b[i]] = cnta[b[i]]: nb_matches += 1
    if i - m + 1 >= 1:
        if cntb[b[i - m + 1]] = cnta[b[i - m + 1]]: nb_matches -= 1
        cntb[b[i - m + 1]] += 1
        if cntb[b[i - m + 1]] = cnta[b[i - m + 1]]: nb_matches += 1
        cntb[b[i - m + 1]] -= 1
return ans

Answer 3

编写函数strcount（）来计算字符串或子字符串str中字符ch的出现次数。

然后只需通过搜索字符串。

  for(i=0;i<haystacklenN-NeedleN+1;i++)
  {
    for(j=0;j<needleN;j++)
       if(strcount(haystack + i, Nneedle, needle[j]) != strcount(needles, needlesN, needle[j])
        break
  }
  if(j == needleN)
         /* found a permuatation */

Answer 4

以下是我的解决方案。空间复杂度只是O(a + b)，运行时间（如果我可以正确计算..）是O(b*a)，对于b中的每个字符，我们可以进行递归{{1深度。

md5的答案很好，而且会更快!!

为了便于搜索，我在此页面上找到了其他解决方案来比较我的问题，问题源于观看此剪辑：https://www.hackerrank.com/domains/tutorials/cracking-the-coding-interview。最初的问题陈述类似于＆＃39;在b＆＃39;中找到s的所有排列。

Answer 5

使用 2 个哈希表，并使用大小 = 较小字符串长度的滑动窗口：

int premutations_of_B_in_A(string large, string small) {
    unordered_map<char, int> characters_in_large;
    unordered_map<char, int> characters_in_small;
    int ans = 0;

    for (char c : small) {
        characters_in_small[c]++;
    }
    for (int i = 0; i < small.length(); i++) {
        characters_in_large[large[i]]++;
        ans += (characters_in_small == characters_in_large);
    }
    for (int i = small.length(); i < large.length(); i++) {
        characters_in_large[large[i]]++;
        if (characters_in_large[large[i - small.length()]]-- == 1)
            characters_in_large.erase(large[i - small.length()]);

        ans += (characters_in_small == characters_in_large);
    }
    return ans;
}

Answer 6

这几乎是解决方案，但会帮助您count 次将小字符串排列成大字符串

made for only lower case chars

此解决方案具有 --

Time Complexity - O(L) 其中 L 是提供给问题的大输入的长度，对于大数组中存在的每个字符，确切地说也包括 26 个字符，但通过忽略常数项，我将仅代表这一点。

Space Complexity - O(1) 因为 26 也是常数并且与输入的大小无关。

int findAllPermutations(string small, string larger) {
    int freqSmall[26] = {0};
    //window size
    int n = small.length();

    //to return
    int finalAns = 0;

    for (char a : small) {
        freqSmall[a - 97]++;
    }

    int freqlarger[26]={0};
    int count = 0;
    int j = 0;

    for (int i = 0; larger[i] != '\0'; i++) {
        freqlarger[larger[i] - 97]++;
        count++;

        if (count == n) {
            count = 0;
            int i;
            for (i = 0; i < 26; i++) {
                if (freqlarger[i] != freqSmall[i]) {
                    break;
                }
            }
            if (i == 26) {
                finalAns++;
            }
            freqlarger[larger[j] - 97]--;
             j++;
        }

    }
    return finalAns;
}

int main() {
    string s, t;
    cin >> s >> t;
    cout << findAllPermutations(s, t) << endl;
    return 0;
}

算法 - 查找字符串b

6 个答案: