String 具有O（m*n）的最长公共子串非DP解

问题的定义是：

给定两个字符串，查找最长的公共子字符串

返回它的长度

我在解决这个问题，我想我用O（m*n）时间复杂性解决了它。然而，我不知道为什么当我查找解决方案时，都在谈论最优解决方案是动态规划-

这是我的解决方案，您可以在这里进行测试：

int longestCommonSubstring（字符串A、字符串B）{
int ans=0；
对于（int i=0；i，您的解决方案是O（nm）复杂度，如果您将结构与提供的算法进行比较，则其完全相同；但是，您的解决方案没有记忆

链接中提供的动态算法的一个优点是，在相同的复杂度类时间中，它可以在O（1）中调用不同的子字符串长度；否则，我觉得它很好

这是一种时不时会发生的事情，因为存储子空间解决方案并不总是产生更好的运行时（第一次调用时），而是产生相同的复杂度类运行时（例如，尝试使用动态解计算第n个斐波那契数，并将其与尾部递归解进行比较。注意，在这种情况下，与您的情况类似，在第一次填充数组后，每次连续调用都会更快地返回答案。
您的解为O（nm）复杂度，如果你看一下，将结构与提供的算法进行比较，它们是完全相同的；但是，你的并不记忆

链接中提供的动态算法的一个优点是，在相同的复杂度类时间中，它可以在O（1）中调用不同的子字符串长度；否则，我觉得它很好

这是一种时不时会发生的事情，因为存储子空间解决方案并不总是产生更好的运行时（第一次调用时），而是产生相同的复杂度类运行时（例如，尝试使用动态解计算第n个斐波那契数，并将其与尾部递归解进行比较。请注意，在这种情况下，与您的情况类似，在第一次填充数组后，每次连续调用都会更快地返回答案。
好消息：您的算法是O（mn）。坏消息：它无法正常工作

您的内部循环是错误的：它旨在查找B中A[i:]的最长初始子字符串，但其工作原理如下：

j = 0
While j < len(B)
   Match as much of A[i:] against B[j:]. Call it s.
   Remember s if it's the longest so far found.
   j += len(s)

j=0
而j

这无法找到最长的匹配项。例如，当A=“XXY”和B=“XXXY”且i=0时，它将找到“XX”作为最长的匹配项，而不是完整的匹配项“XXY”

下面是代码的可运行版本（轻轻地转录成C），它显示了错误的结果：

#include <string.h>
#include <stdio.h>

int lcs(const char* A, const char* B) {
    int al = strlen(A);
    int bl = strlen(B);
    int ans = 0;
    for (int i=0; i<al; i++) {
        int counter = 0;
        int k = i;
        for (int j=0; j<bl && k<al; j++) {
            if (A[k]!=B[j]) {
                counter = 0;
                k = i;
            } else {
                k++;
                counter++;
                if (counter >= ans) ans = counter;
            }  
        }
    }
    return ans;        
}

int main(int argc, char**argv) {
    printf("%d\n", lcs("XXY", "XXXY"));
    return 0;
}

#包括
#包括
int lcs（常量字符*A，常量字符*B）{
int al=斯特伦（A）；
int bl=strlen（B）；
int ans=0；
对于（inti=0；i好消息：您的算法是O（mn）。坏消息：它不能正常工作

您的内部循环是错误的：它旨在查找B中A[i:]的最长初始子字符串，但其工作原理如下：

j = 0
While j < len(B)
   Match as much of A[i:] against B[j:]. Call it s.
   Remember s if it's the longest so far found.
   j += len(s)

j=0
而j

这无法找到最长的匹配项。例如，当A=“XXY”和B=“XXXY”且i=0时，它将找到“XX”作为最长的匹配项，而不是完整的匹配项“XXY”

下面是代码的可运行版本（轻轻地转录成C），它显示了错误的结果：

#include <string.h>
#include <stdio.h>

int lcs(const char* A, const char* B) {
    int al = strlen(A);
    int bl = strlen(B);
    int ans = 0;
    for (int i=0; i<al; i++) {
        int counter = 0;
        int k = i;
        for (int j=0; j<bl && k<al; j++) {
            if (A[k]!=B[j]) {
                counter = 0;
                k = i;
            } else {
                k++;
                counter++;
                if (counter >= ans) ans = counter;
            }  
        }
    }
    return ans;        
}

int main(int argc, char**argv) {
    printf("%d\n", lcs("XXY", "XXXY"));
    return 0;
}

#包括
#包括
int lcs（常量字符*A，常量字符*B）{
int al=斯特伦（A）；
int bl=strlen（B）；
int ans=0；
例如（inti=0；我认为“好消息”与坏消息无关。我可以在
O（1）
时间内得到错误的答案，这会更有效率。：）我认为“好消息”与坏消息无关。我可以在
O（1）
时间内得到错误的答案，这会更有效率。：）如果正确实施，您用文字描述的解决方案将是
O（nm^2）
。这就是为什么DP解决方案是必要的。如果正确实施，您用文字描述的解决方案将是
O（nm^2）
。这就是为什么DP解决方案是必要的。