如何更有效地计算 n 个字符串之间的不匹配分数？

Question

假设我有一个包含n 字符串的向量，其中字符串的长度可以是 5...n。每个字符串必须逐个字符地与每个字符串进行比较。如果不匹配，则分数增加一。如果有匹配，则分数不会增加。然后我会将得到的分数存储在一个矩阵中。

我通过以下方式实现了这一点：

for (auto i = 0u; i < vector.size(); ++i)
{
  // vector.size() x vector.size() matrix
  std::string first = vector[i]; //horrible naming convention
  for (auto j = 0u; j < vector.size(); ++j)
  {
    std::string next = vector[j];
    int score = 0;
    for (auto k = 0u; k < sizeOfStrings; ++k)
    {
      if(first[k] == second[k])
      {
        score += 0;
      }
      else
      {
        score += 1;
      }
    }
    //store score into matrix
  }
}

我对这个解决方案不满意，因为它是O(n^3)。所以我一直在想其他方法来提高效率。我曾考虑编写另一个函数来替换我们的 j for 循环的内部结构，但是，它仍然是 O(n^3)，因为该函数仍然需要一个 k 循环。

我也考虑过队列，因为与string[1] 到string[n] 相比，我只关心string[0]。 String[1] 与 string[2] 与 string[n] 相比。 String[2] 与 string[3] 到 string[n] 相比，等等。所以我的解决方案有不必要的计算，因为每个字符串都在与其他字符串进行比较。这个问题是我不确定如何从中构建我的矩阵。

我终于查看了 std 模板库，但是 std::mismatch 似乎不是我想要的，或者 std::find。大家还有什么想法？

Answer 1

我认为您无法轻松摆脱 O(n^3) 比较，但您可以轻松实现您所说的更改。由于只需要以一种方式进行比较（即比较 string[1] 到 string[2] 与比较 string[2] 到 string[1] 相同），正如您所指出的，您不需要迭代每次遍历整个数组，并且可以将内循环的起始值更改为外循环的当前索引：

for (auto i = 0u; i < vector.size(); ++i) {
    // vector.size() x vector.size() matrix
    std::string first = vector[i]; //horrible naming convention
    for (auto j = i; j < vector.size(); ++j) {

要将其存储在矩阵中，请设置您的i x j 矩阵，将其初始化为全零并将每个分数存储在M[i][j]

for (auto k = 0u; k < sizeOfStrings; ++k) {
    if (first[k] != second[k]) {
        M[i][j]++;
    }
}

Answer 2

如果你有 n 个长度为 m 的字符串，那么无论如何（即使你有队列的想法），你至少必须做 (n-1)+(n-2)+...+(1) =n(n-1)/2 字符串比较，所以你必须做 (n(n-1)/2)*m 字符比较。所以无论如何，你的算法将是 O(mn^2)。

Answer 3

• 一般性评论：

您不必相互比较相同的字符串。更重要的是，您在第二个循环中每次从头开始，而您已经计算了这些差异，因此将第二个循环更改为从 i+1 开始。 通过这样做，您的复杂性将会降低，因为您不会检查您已经检查过或相同的字符串。

• 改进

对向量进行排序并删除重复的条目，而不是浪费计算来检查相同的字符串，您只会检查不同的字符串。

Answer 4

说这至少是 O(mn^2) 或 O(n^3) 的其他答案是不正确的。这可以在 O(mn) 时间内完成，其中 m 是字符串大小，n 是字符串数。

为简单起见，我们先假设所有字符都是 ascii。

你有一个数据结构：

int counts[m][255]

其中 counts[x][y] 是字符串中索引 x 处具有 ascii 字符 y 的字符串数。

现在，如果您不限于 ascii，那么您将需要使用 std::map

map counts[m]

但它的工作方式相同，在索引 m 处，您有一个映射，其中映射 y,z 中的每个条目告诉您有多少字符串 z 在索引 m 处使用字符 y。您还需要选择具有恒定时间查找和恒定时间插入的地图以匹配复杂性。

回到ascii和数组

int counts[m][255] // start by initializing this array to all zeros

首先初始化数据结构：

m 是字符串的大小， vec 是带有字符串的 std::vector

for (int i = 0; i < vec.size(); i++) {
    std::string str = vec[i];
    for(int j = 0; j < m; j++) {
        counts[j][str[j]]++;
    }
}

现在你有了这个结构，你可以很容易地计算分数：

for (int i = 0; i < vec.size(); i++) {
    std::string str = vec[i];
    int score = 0;
    for(int j = 0; j < m; j++) {
            score += counts[j][str[j]] - 1; //subtracting 1 gives how many other strings have that same char at that index
    }
    std::cout << "string \"" << str << "\" has score " << score;
}

从这段代码可以看出，这是 O(m * n)