hdu 1159 Common Subsequence 【LCS 基础入门】

链接：

http://acm.hdu.edu.cn/showproblem.php?pid=1159

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=28195#problem/A

Common Subsequence

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 17621    Accepted Submission(s): 7401

Problem Description

A subsequence of a given sequence is the given sequence with some elements (possible none) left out. Given a sequence X = <x1, x2, ..., xm> another sequence Z = <z1, z2, ..., zk> is a subsequence of X if there exists a strictly increasing sequence <i1, i2, ..., ik> of indices of X such that for all j = 1,2,...,k, xij = zj. For example, Z = <a, b, f, c> is a subsequence of X = <a, b, c, f, b, c> with index sequence <1, 2, 4, 6>. Given two sequences X and Y the problem is to find the length of the maximum-length common subsequence of X and Y. 
The program input is from a text file. Each data set in the file contains two strings representing the given sequences. The sequences are separated by any number of white spaces. The input data are correct. For each set of data the program prints on the standard output the length of the maximum-length common subsequence from the beginning of a separate line. 

 

Sample Input

    
    
    
    

     
     
     
     abcfbc abfcab
programming contest 
abcd mnp
    
    
    
    

 

Sample Output

    
    
    
    

     
     
     
     4
2
0
    
    
    
    

 

Source

Southeastern Europe 2003

 

Recommend

Ignatius

 

题意： 

      求最长公共上升子序列

        就是第一个序列和第二个序列中有几个相同的。

        子序列：

                如果有一个序列 <A1, A2, A3,... An> 还有个序列 <Ak1, A k2, ... A kn> 满足 k1 < k2 < k3，

                那么 第二个序列是第一个序列的子序列

        最长公共子序列：

                就是从几个序列【一般是两个了】中找出一样的最长的子序列

分析：

用 dp[i][j] 记录序列 A 中从 0 到 i-1  和序列 B 中从 0  到 j-1  的最长公共子序列长度

O（n^n）写法：

先初始化 dp 为 0

当 A 序列遍历到第 i-1 个,序列 B  遍历到第 j-1 个

1) 如果此时 A[i-1] == B[j-1] , 那么可想而知 dp[i][j] = dp[i-1][j-1] +1

2) 如果此时 A[i-1] != B[j-1], 那么 dp[i][j] = max( dp[i-1][j],  dp[i][j-1] )

总之相当于记忆化搜索的了 dp[i][j] 从左到右从上到下, 当确立了当前字符是否相等时

那么 dp[i][j] 就由它的左上角 ( dp[i-1][j-1] )、上面的 ( dp[i-1][j] )、前面的 ( dp[i][j-1] ) 确定

/**
求长度为 len1 的序列 A 和长度为 len2 的序列 B 的LCS
注意：序列下标从 0 开始
*/
void LCS(int len1,int len2)
{
    for(int i = 1; i <= len1; i++)
    {
        for(int j = 1; j <= len2; j++)
        {
            if(s1[i-1] == s2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
            else
            {
                int m1 = dp[i-1][j];
                int m2 = dp[i][j-1];
                dp[i][j] = max(m1, m2);
            }
        }
    }
}

比完赛了学妹提到的，将 dp[maxn][maxn]优化到 dp[2][maxn]

其实也是滚动数组的概念了：

由上面的分析我们发现这一点：当前的 dp[i][j] 只是与以它为右下角的四个 dp 有关

dp[i-1][j-1]  dp[i-1][j]

dp[i][j-1]     dp[i][j]

而我们并不是要求出每一段的 LCS 而只是求出最终的长度的 LCS,那么每次对 i %2 就可以解决问题

这样就大大优化了内存

void LCS(int len1,int len2)
{
    for(int i = 1; i <= len1; i++)
    {
        for(int j = 1; j <= len2; j++)
        {
            if(s1[i-1] == s2[j-1]) dp[i%2][j] = dp[(i-1)%2][j-1]+1;
            else
            {
                int m1 = dp[(i-1)%2][j];
                int m2 = dp[i%2][j-1];
                dp[i%2][j] = max(m1, m2);
            }
        }
    }
}

code：

普通：

A

Accepted

1244 KB

31 ms

C++

749 B

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn = 500+10;
int dp[maxn][maxn];
char s1[maxn], s2[maxn];

/**
求长度为 len1 的序列 A 和长度为 len2 的序列 B 的LCS
注意：序列下标从 0 开始
*/
void LCS(int len1,int len2)
{
    for(int i = 1; i <= len1; i++)
    {
        for(int j = 1; j <= len2; j++)
        {
            if(s1[i-1] == s2[j-1]) dp[i][j] = dp[i-1][j-1]+1;
            else
            {
                int m1 = dp[i-1][j];
                int m2 = dp[i][j-1];
                dp[i][j] = max(m1, m2);
            }
        }
    }
}

int main()
{
     while(scanf("%s%s", s1,s2) != EOF)
     {
         int len1 = strlen(s1);
         int len2 = strlen(s2);
         memset(dp,0,sizeof(dp));

         LCS(len1, len2);
         printf("%d\n", dp[len1][len2]);
     }
}

滚动数组：

Accepted

1159

31MS

232K

794 B

C++

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn = 500+10;
int dp[2][maxn];
char s1[maxn], s2[maxn];

void LCS(int len1,int len2)
{
    for(int i = 1; i <= len1; i++)
    {
        for(int j = 1; j <= len2; j++)
        {
            if(s1[i-1] == s2[j-1]) dp[i%2][j] = dp[(i-1)%2][j-1]+1;
            else
            {
                int m1 = dp[(i-1)%2][j];
                int m2 = dp[i%2][j-1];
                dp[i%2][j] = max(m1, m2);
            }
        }
    }
}

int main()
{
     while(scanf("%s%s", s1,s2) != EOF)
     {
         int len1 = strlen(s1);
         int len2 = strlen(s2);
         memset(dp,0,sizeof(dp));

         LCS(len1, len2);
         printf("%d\n", dp[len1%2][len2]);
     }
}