C++ 关于最长公共子串的探讨

在中的编程挑战中，我采用了与一般最长公共子串问题不同的方法。代码是

#include <cmath>
#include <cstdio>
#include <vector>
#include<string>
#include <iostream>
#include <algorithm>
using namespace std;

void max(string a,string b,int n)
{
    int count=0,x=-1,prev=0,i,j,k;
    for(i=0;i<n;i++)
    {
        x=-1;
        for(j=i;j<n;j++)
        {
            for(k=x+1;k<n;k++)
            {
                if(a[j]==b[k])
                {
                    count++;
                    x=k;
                    break;
                }
            }
        }
        if(prev<count)
        {
            prev=count;
        }
        count=0;        
    }
    cout<<prev;
}

int main() {
    string a,b;
    int n;
    cin>>a;
    cin>>b;
    n=a.length();
    max(a,b,n);
    return 0;

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
最大无效值（字符串a、字符串b、整数n）
{
int count=0，x=-1，prev=0，i，j，k；
对于（i=0；i我预见的一个问题如下：

如果a=ABCDEFG，b=ACDEFGB

现在它将首先匹配A，然后匹配B，但随后k将变成6。因此，更多的字母CDEFG将不匹配

因此，应跳过可能的字符串ACDEFG

您的代码将以CDEFG的形式返回最大公共子级

编辑：这不是一个最长的公共子串问题，而是一个最长的公共子串问题。
问题在于，您的算法使用了一种幼稚的贪婪方法：它一看到匹配就立即进行匹配，并且在到达下一个子串之前，永远不会重新考虑它的决定。可以用计数器进行演示xxx认为这个贪婪策略不适用于：考虑字符串

A = "abcd"
B = "acdb"

您的算法，因为它为
“ab”
，而最长的子序列是
“acd”
，长度为3

这两个字符串是精心构造的，用于欺骗算法生成错误的结果。您的算法将在初始位置匹配
'a'
s，前进到字符串
a
的第二个字符
'b'
，并在字符串
b
的最后一个位置匹配。此时，您的算法是注定失败：它找不到
'c'
和
'd'
，因为
B
的所有字符都已用尽。它应该做的是，通过回溯匹配
'B'
的决定，似乎可以做得更好。对此的答案是响亮的“是”：如果跳过
A
的第二个字符，我们将同时匹配
'c'
和
'd'
，以获得正确的结果3

LCS的正确实现（使用DP或记忆）可以在不以指数方式增长时间的情况下进行回溯。它是研究和实现的最简单的DP算法之一，因此应用它来解决手头的问题应该不会有问题。
import java.util.Scanner；
import java.util.Scanner;
  public class JavaApplication8 {
      public static int find(String s1,String s2){
        int n = s1.length();
        int m = s2.length();
        int ans = 0;
        int[] a = new int[m];
        int b[] = new int[m];
        for(int i = 0;i<n;i++){
            for(int j = 0;j<m;j++){
                if(s1.charAt(i)==s2.charAt(j)){
                   if(i==0 || j==0 )a[j] = 1;
                   else{
                       a[j] = b[j-1] + 1;
                   }
                   ans = Math.max(ans, a[j]);
                }

            }
            int[] c = a;
            a = b;
            b = c;
        }
        return ans;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        String s2 = sc.next();
        System.out.println(find(s1,s2));
    }

}

公共类JavaApplication8{
公共静态整型查找（字符串s1、字符串s2）{
int n=s1.length（）；
int m=s2.length（）；
int ans=0；
int[]a=新的int[m]；
int b[]=新的int[m]；
对于（int i=0；我不明白这一点的最后投票结果：这个问题是完整的，而且非常有意义。