10405 - Longest Common Subsequence UVA

本文介绍了一种求解两个字符串最长公共子序列的问题,并通过动态规划的方法给出了详细的算法实现过程。文章提供了完整的C++代码示例,展示了如何利用递归与数组两种方式高效地解决此类问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 Longest Common Subsequence

Sequence 1:                

Sequence 2:                Given two sequences of characters, print the length of the longest common subsequence of both sequences. For example, the longest common subsequence of the following two sequences:

abcdgh
aedfhr
is  adh  of length 3.

Input consists of pairs of lines. The first line of a pair contains the first string and the second line contains the second string. Each string is on a separate line and consists of at most 1,000 characters

For each subsequent pair of input lines, output a line containing one integer number which satisfies the criteria stated above.

Sample input

a1b2c3d4e
zz1yy2xx3ww4vv
abcdgh
aedfhr
abcdefghijklmnopqrstuvwxyz
a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0
abcdefghijklmnzyxwvutsrqpo
opqrstuvwxyzabcdefghijklmn

Output for the sample input

4
3
26
14
 
 
自己做的第一个动态规划的基础题:
关键是找到其状态转移方程!!!
不妨设d(x,y)代表字符串A1,A2....Ax和字符串B1,B2.....By
最长公共字符串
那么当Ax=By的时候
有:
d(x,y)= d(x-1,y-1)+1;
如果Ax !=By时
那么:
d(x,y) = max(d(x-1,y),d(x,y-1);
代码如下:
A[x-1]==B[y-1]//注意是x-1和y-1而非x,y
注意读入字符串此处必须用gets用scanf会wr
杭电完全类似的题目
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;
char A[1100];
char B[1100];
int d[1100][1100];
int vis[1100][1100];
int dp(int x,int y)
{
    if(vis[x][y])
    return d[x][y];
    vis[x][y] = 1;
    if(x==0||y==0)
    d[x][y] = 0;
    else
    {
    if(A[x-1]==B[y-1])
     d[x][y] = dp(x-1,y-1) + 1;
    else
     d[x][y] = max(dp(x-1,y),dp(x,y-1));
    }
     return d[x][y];
}
int main()
{
    while(gets(A)&&gets(B))
    {
        memset(vis,0,sizeof(vis));
        int la = strlen(A);
        int lb = strlen(B);
        for(int i = 0;i<=lb;++i)
          d[0][i] = 0;
        for(int i = 0;i<=la;++i)
          d[i][0] = 0;
          printf("%d\n",dp(la,lb));
    }
}


 
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;
char A[1100];
char B[1100];
int d[1100][1100];
int vis[1100][1100];
int dp(int x,int y)
{
    if(vis[x][y])
    return d[x][y];
    vis[x][y] = 1;
    if(x==0||y==0)
    d[x][y] = 0;
    else
    {
    if(A[x-1]==B[y-1])
     d[x][y] = dp(x-1,y-1) + 1;
    else
     d[x][y] = max(dp(x-1,y),dp(x,y-1));
    }
     return d[x][y];
}
int main()
{
    while(gets(A)&&gets(B))
    {
        memset(vis,0,sizeof(vis));
        int la = strlen(A);
        int lb = strlen(B);
          printf("%d\n",dp(la,lb));
    }
}

下面是完全用数组做的:
 
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;
char A[1100];
char B[1100];
int d[1100][1100];
int main()
{
    while(gets(A)&&gets(B))
    {
        int la = strlen(A);
        int lb = strlen(B);
        for(int i = 0;i<=la;++i)
        d[i][0] = 0;
        for(int i = 0;i<=lb;++i)
        d[0][i] = 0;
        for(int i = 1;i<=la;++i)
          for(int j = 1;j<=lb;++j)
          {
              if(A[i-1]==B[j-1])
              d[i][j] = d[i-1][j-1]+1;
              else
              d[i][j] = max(d[i-1][j],d[i][j-1]);
          }
        printf("%d\n",d[la][lb]);
    }
}



                
### 回答1: 最长公共子序列(Longest Common Subsequence)指的是在两个序列中找到最长的公共子序列,这个公共子序列可以不连续,但是需要保持相对顺序不变。例如,对于序列ABCD和ACDFG,它们的最长公共子序列是ACD。 ### 回答2: 最长公共子序列(Longest Common Subsequence,简称LCS)是指在给定多个序列中,找到最长的一个子序列,该子序列同时出现在这些序列中,并且其他元素的相对顺序保持一致。 举个例子,假设有两个序列A和B,A为[1, 2, 3, 4, 5],B为[2, 4, 5, 6]。它们的一个最长公共子序列是[2, 4, 5],该子序列同时存在于A和B中。 求解LCS的问题可以用动态规划的方法来解决。我们可以构建一个二维数组dp,其中dp[i][j]表示序列A的前i个元素和序列B的前j个元素的LCS长度。那么dp[i][j]可以通过以下方式得到: 1. 如果A[i]等于B[j],则dp[i][j]等于dp[i-1][j-1] + 1; 2. 如果A[i]不等于B[j],则dp[i][j]等于max(dp[i-1][j], dp[i][j-1])。 通过填充整个dp数组,最终可以得到序列A和序列B的LCS长度。要找到具体的LCS序列,则可以通过反向遍历dp数组进行构建。 LCS问题在字符串处理、DNA序列匹配、版本控制等领域都有广泛的应用。其时间复杂度为O(m*n),其中m和n分别为序列A和序列B的长度。 ### 回答3: 最长公共子序列(Longest Common Subsequence)是一个经典的计算机科学问题。给定两个序列S和T,我们要找出它们之间最长的公共子序列。 子序列是从给定序列中按顺序选择几个元素而组成的序列。而公共子序列指的是同时是序列S和T的子序列的序列。 为了解决这个问题,可以使用动态规划的方法。我们可以定义一个二维数组dp,其中dp[i][j]表示序列S的前i个元素和序列T的前j个元素之间的最长公共子序列的长度。 接下来,我们可以使用以下递推关系来填充dp数组: 如果S[i]等于T[j],则dp[i][j] = dp[i-1][j-1] + 1; 如果S[i]不等于T[j],则dp[i][j] = max(dp[i-1][j], dp[i][j-1])。 最后,我们可以通过查看dp[S.length()][T.length()]来得到最长公共子序列的长度。 此外,我们也可以用回溯法来还原最长公共子序列本身。我们可以从dp[S.length()][T.length()]开始,如果S[i]等于T[j],则将S[i]添加到结果序列中,并向左上方移动,即i = i-1,j = j-1。如果S[i]不等于T[j],则根据dp数组的值选择向上(i = i-1)或向左(j = j-1)移动。 总之,最长公共子序列问题是一个经典的计算机科学问题,可以使用动态规划的方法解决。我们可以通过构建二维dp数组来计算最长公共子序列的长度,并可以使用回溯法来还原它本身。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值