Question

如果列出了长度为l的正确单词列表以及长度为l的错误单词列表，请在列表中找到与纠正单词列表不同的单词交换两个连续的字母。这些话被认为是拼写错误。例如，hte被视为the的拼写错误，而het不被视为拼写错误。

什么是最佳时间效率算法，允许我们通过此定义查找被视为拼写错误的单词列表？

我被告知列表可能是以线性时间计算的，但我没有找到线性时间的解决方案。我能想到的唯一方法是将一个列表中的所有字母与另一个列表中的强力进行比较。

Answer 1

L - list of correct words of size n.
L'- list of incorrect words of size m.
H - hash table
R - result set

1. for each word w in L :
   1.1  for each typo t of w : //there are l-1 typos
     1.1.1 insert t into H
2. for each word w' in L' :
   2.1 if w' in H insert w' in R
3. return R

时间复杂度： O(n*l)+O(m) = O(max(n*l,m))

空间复杂性： O(n*l)

Answer 2

假设每个“拼写错误”的单词中只能进行单次交换：

从一个空的HashTable H开始。

对于INCORRECT字列表中的每个单词K：

通过交换每对连续字符生成（l-1）个新单词：K_1，K_2，...，K_x，...，K_（l-1）
- 对于这些新单词中的每一个，将其添加到HashTable H，其中键为K_x，值为K（原始错误单词）

现在对于CORRECT单词列表中的每个单词C，：

对于每个C，检查密钥C是否存在于HashTable H中。
如果密钥C存在于HashTable H中，则输出与C：相关联的值C'，因为这些值最初都来自INCORRECT单词列表，我们必须找到一个不正确的单词，其中，通过交换2个连续的字母，将其翻转正确的话。
输出每个这样的C'

因为l是固定数字（必须是，否则你可以同时将l和n同时增长到无穷大，否则没有线性时间算法），你有以下运行时复杂性：

通过错误的单词列表需要线性时间
在不正确的单词列表
将每个（新单词，K）添加到HashTable H
通过正确的单词列表需要线性时间
根据HashTable H

因此，这是O（n）运行时。

Answer 3

findTypos(List CORRECT_LIST,
List INCORRECT_LIST,
List TYPOS_OUTPUT_LIST) {
 boolean INCORRECT_LIST_EMPTY = false  

 for each element in CORRECT_LIST {  
    TYPOS = computeTypos(element)  
    for each typo in TYPOS  
        if(INCORRECT_LIST.contains(typo)) {  
            INCORRECT_LIST.remove(typo)  
            TYPOS_OUTPUT_LIST.add(typo)  
        }  
        if(INCORRECT_LIST.size() == 0) {  
            INCORRECT_LIST_EMPTY = true;  
            break;  
        }  
    }  
    if(INCORRECT_LIST_EMPTY) {  
        break;  
    }  
 }
 return TYPOS_OUTPUT_LIST;
}

Answer 4

以下是SINGLE交换案例的解决方案。我假设每个单词只有一个交换。因此，对于单词algorithm，algo[ir]thm是有效的拼写错误;而[la]go[ir]thm无效。

让我们调用正确的单词列表A和其他列表B。

从列表H_B创建一个哈希表，B个不正确的单词。像这样的散列函数
```
Σ(a_i*10ⁱ); where 0 <= i <  a.length, a_i = int value of character at index i
```
这是O(l)。

2.迭代A。

(assume base 1 index)

typo = []
for i = 1 to A.length
  for j = A[i].length down-to 2
    temp = swap(A[i], j, j-1)
    hash = getHash(temp)
    if(H_B.has(hash))
      typo.add(temp)
return typo

你看到两个循环？他们执行了多少次？让我们做数学

a₁.length + a₂.length + .. +a_l.length - l
(the minus l is because we are actually iterating one less in each words)
= length_of_all_characters_the_list_A - l

但我如何获得订单？好吧，大O是上限，所以

O(l*max(A[i].length)
=> O(l*m)

在单词列表中查找拼写错误

4 个答案: