跟着编程之美学算法——最长公共子序列

最长公共子序列是一个很经典的动态规划问题，最近正在学习动态规划，所以拿来这里再整理一下。

这个问题在《算法导论》中作为讲动态规划算法的例题出现。

动态规划，众所周知，第一步就是找子问题，也就是把一个大的问题分解成子问题。这里我们设两个字符串A、B，A = "a0, a1, a2, ..., am-1"，B = "b0, b1, b2, ..., bn-1"。

（1）如果am-1 == bn-1，则当前最长公共子序列为"a0, a1, ..., am-2"与"b0, b1, ..., bn-2"的最长公共子序列与am-1的和。长度为"a0, a1, ..., am-2"与"b0, b1, ..., bn-2"的最长公共子序列的长度+1。

（2）如果am-1 != bn-1，则最长公共子序列为max（"a0, a1, ..., am-2"与"b0, b1, ..., bn-1"的公共子序列，"a0, a1, ..., am-1"与"b0, b1, ..., bn-2"的公共子序列）

如果上述描述用数学公式表示，则引入一个二维数组c[][]，其中c[i][j]记录X[i]与Y[j]的LCS长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，即，搜索方向。

这样我们可以总结出该问题的递归形式表达：

按照动态规划的思想，对问题的求解，其实就是对子问题自底向上的计算过程。这里，计算c[i][j]时，c[i-1][j-1]、c[i-1][j]、c[i][j-1]已经计算出来了，这样，我们可以根据X[i]与Y[j]的取值，按照上面的递推，求出c[i][j]，同时把路径记录在b[i][j]中（路径只有3中方向：左上、左、上，如下图）。

计算c[][]矩阵的时间复杂度是O(m*n)；根据b[][]矩阵寻找最长公共子序列的过程，由于每次调用至少向上或向左移动一步，这样最多需要（m+n）次就会i = 0或j = 0，也就是算法时间复杂度为O(m+n)。

一下是代码实现

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <string>
  4 #include <string.h>
  5
  6 using namespace std;
  7
  8 void LCS_Print(int **LCS_Direction, char *str, int row, int column)
  9 {
 10     if(str == NULL)
 11         return;
 12
 13     int nLen1 = strlen(str);
 14
 15     if(nLen1 == 0 || row < 0 || column < 0)
 16         return;
 17
 18     if(LCS_Direction[row][column] == 1)
 19     {
 20         if(row > 0 && column > 0)
 21             LCS_Print(LCS_Direction, str, row - 1, column - 1);
 22         printf("%c ", str[row]);
 23     }
 24     else if(LCS_Direction[row][column] == 2)
 25     {
 26         if(row > 0)
 27             LCS_Print(LCS_Direction, str, row - 1, column);
 28     }
 29     else if(LCS_Direction[row][column] == 3)
 30     {
 31         if(column > 0)
 32             LCS_Print(LCS_Direction, str, row, column - 1);
 33     }
 34 }
 35
 36 int LCS(char *str1, char *str2)
 37 {
 38     if(str1 == NULL || str2 == NULL)
 39         return 0;
 40
 41     int nLen1 = strlen(str1);
 42     int nLen2 = strlen(str2);
 43
 44     if(nLen1 <= 0 || nLen2 <= 0)
 45         return 0;
 46
 47     // 申请一个二维数组，保存不同位置的LCS值
 48     int **LCS_Length = new int*[nLen1];
 49     // 申请一个二维数组，保存公共序列的位置
 50     int **LCS_Direction = new int*[nLen1];
 51     for(int i = 0; i < nLen1; i++)
 52     {
 53         LCS_Length[i] = new int[nLen2];
 54         LCS_Direction[i] = new int[nLen2];
 55     }
 56
 57     for(int i = 0; i < nLen1; i++)
 58         LCS_Length[i][0] = 0;
 59     for(int i = 0; i < nLen2; i++)
 60         LCS_Length[0][i] = 0;
 61
 62     for(int i = 0; i < nLen1; i++)
 63     {
 64         for(int j = 0; j < nLen2; j++)
 65         {
 66             LCS_Direction[i][j] = 0;
 67         }
 68     }
 69
 70     cout<<"Init OK!"<<endl;
 71
 72     for(int i = 0; i <nLen1; i++)
 73     {
 74         for(int j = 0; j < nLen2; j++)
 75         {
 76             if(i == 0 || j == 0)
 77             {
 78                 if(str1[i] == str2[j])
 79                 {
 80                     LCS_Length[i][j] = 1;
 81                     LCS_Direction[i][j] = 1;
 82                 }
 83                 else
 84                     LCS_Length[i][j] = 0;
 85             }
 86             else if(str1[i] == str2[j])
 87             {
 88                 LCS_Length[i][j] = LCS_Length[i - 1][j - 1] + 1;
 89                 LCS_Direction[i][j] = 1;
 90             }
 91             else if(LCS_Length[i - 1][j] > LCS_Length[i][j - 1])
 92             {
 93                 LCS_Length[i][j] = LCS_Length[i - 1][j];
 94                 LCS_Direction[i][j] = 2;
 95             }
 96             else
 97             {
 98                 LCS_Length[i][j] = LCS_Length[i][j - 1];
 99                 LCS_Direction[i][j] = 3;
100             }
101         }
102     }
103
104     LCS_Print(LCS_Direction, str1, nLen1 - 1, nLen2 - 1);
105     cout<<endl;
106     int nLCS = LCS_Length[nLen1 - 1][nLen2 - 1];
107     for(int i = 0; i < nLen1; i++)
108     {
109         delete[] LCS_Length[i];
110         delete[] LCS_Direction[i];
111     }
112     delete [] LCS_Length;
113     delete [] LCS_Direction;
114     return nLCS;
115 }
116
117 int main()
118 {
119     cout<<LCS("ABCBDAB", "BDCABA")<<endl;
120     return 0;
121 }
复制代码

  1 #include <iostream>
  2 #include <stdio.h>
  3 #include <string>
  4 #include <string.h>
  5
  6 using namespace std;
  7
  8 void LCS_Print(int **LCS_Direction, char *str, int row, int column)
  9 {
 10     if(str == NULL)
 11         return;
 12
 13     int nLen1 = strlen(str);
 14
 15     if(nLen1 == 0 || row < 0 || column < 0)
 16         return;
 17
 18     if(LCS_Direction[row][column] == 1)
 19     {
 20         if(row > 0 && column > 0)
 21             LCS_Print(LCS_Direction, str, row - 1, column - 1);
 22         printf("%c ", str[row]);
 23     }
 24     else if(LCS_Direction[row][column] == 2)
 25     {
 26         if(row > 0)
 27             LCS_Print(LCS_Direction, str, row - 1, column);
 28     }
 29     else if(LCS_Direction[row][column] == 3)
 30     {
 31         if(column > 0)
 32             LCS_Print(LCS_Direction, str, row, column - 1);
 33     }
 34 }
 35
 36 int LCS(char *str1, char *str2)
 37 {
 38     if(str1 == NULL || str2 == NULL)
 39         return 0;
 40
 41     int nLen1 = strlen(str1);
 42     int nLen2 = strlen(str2);
 43
 44     if(nLen1 <= 0 || nLen2 <= 0)
 45         return 0;
 46
 47     // 申请一个二维数组，保存不同位置的LCS值
 48     int **LCS_Length = new int*[nLen1];
 49     // 申请一个二维数组，保存公共序列的位置
 50     int **LCS_Direction = new int*[nLen1];
 51     for(int i = 0; i < nLen1; i++)
 52     {
 53         LCS_Length[i] = new int[nLen2];
 54         LCS_Direction[i] = new int[nLen2];
 55     }
 56
 57     for(int i = 0; i < nLen1; i++)
 58         LCS_Length[i][0] = 0;
 59     for(int i = 0; i < nLen2; i++)
 60         LCS_Length[0][i] = 0;
 61
 62     for(int i = 0; i < nLen1; i++)
 63     {
 64         for(int j = 0; j < nLen2; j++)
 65         {
 66             LCS_Direction[i][j] = 0;
 67         }
 68     }
 69
 70     cout<<"Init OK!"<<endl;
 71
 72     for(int i = 0; i <nLen1; i++)
 73     {
 74         for(int j = 0; j < nLen2; j++)
 75         {
 76             if(i == 0 || j == 0)
 77             {
 78                 if(str1[i] == str2[j])
 79                 {
 80                     LCS_Length[i][j] = 1;
 81                     LCS_Direction[i][j] = 1;
 82                 }
 83                 else
 84                     LCS_Length[i][j] = 0;
 85             }
 86             else if(str1[i] == str2[j])
 87             {
 88                 LCS_Length[i][j] = LCS_Length[i - 1][j - 1] + 1;
 89                 LCS_Direction[i][j] = 1;
 90             }
 91             else if(LCS_Length[i - 1][j] > LCS_Length[i][j - 1])
 92             {
 93                 LCS_Length[i][j] = LCS_Length[i - 1][j];
 94                 LCS_Direction[i][j] = 2;
 95             }
 96             else
 97             {
 98                 LCS_Length[i][j] = LCS_Length[i][j - 1];
 99                 LCS_Direction[i][j] = 3;
100             }
101         }
102     }
103
104     LCS_Print(LCS_Direction, str1, nLen1 - 1, nLen2 - 1);
105     cout<<endl;
106     int nLCS = LCS_Length[nLen1 - 1][nLen2 - 1];
107     for(int i = 0; i < nLen1; i++)
108     {
109         delete[] LCS_Length[i];
110         delete[] LCS_Direction[i];
111     }
112     delete [] LCS_Length;
113     delete [] LCS_Direction;
114     return nLCS;
115 }
116
117 int main()
118 {
119     cout<<LCS("ABCBDAB", "BDCABA")<<endl;
120     return 0;
121 }

跟着编程之美学算法——最长公共子序列

时间： 2024-08-10 21:28:39

跟着编程之美学算法——最长公共子序列的相关文章

编程算法 - 最长公共子序列(LCS) 代码(C)

最长公共子序列(LCS) 代码(C) 本文地址: http://blog.csdn.net/caroline_wendy 题目: 给定两个字符串s,t, 求出这两个字符串最长的公共子序列的长度. 字符串的子序列并一定要连续, 能够包含间隔. 即最长公共子序列问题(LCS, Longest Common Subsequence) 使用动态规划, 假设字符相等, 两个字符串就依次递增一位, 一直到字符串的结尾. 代码: /* * main.cpp * * Created on: 2014.7.17

算法 | 最长公共子序列

#include<stdio.h> #include<string.h> #define MaxN 10000 #define MaxC 10000 int Val[MaxN][MaxN]; double binaryKnapsack(int numItems, int *w,int *v, int capacity) { int i, j; for(i = 1; i <= numItems; ++i) { for(j = 1; j <= capacity; j++)

LCS问题（最长公共子序列）-动态规划实现

问题描述: 问题] 求两字符序列的最长公共字符子序列 注意: 并不要求子串(字符串一)的字符必须连续出现在字符串二中. 思路分析: 最优子结构和重叠子问题的性质都具有,所以要采取动态规划的算法 最长公共子序列的结构 设序列X= 其中Xm-1= 子问题的递归结构 由最长公共子序列问题的最优子结构性质可知,要找出X= 由此递归结构容易看到最长公共子序列问题具有子问题重叠性质. 例如,在计算X和Y的最长公共子序列时,可能要计算出X和Yn-1及Xm-1和Y的最长公共子序列.而这两个子问题都包含一个公共子

动态规划算法解最长公共子序列LCS问题

第一部分.什么是动态规划算法 ok,咱们先来了解下什么是动态规划算法. 动态规划一般也只能应用于有最优子结构的问题.最优子结构的意思是局部最优解能决定全局最优解(对有些问题这个要求并不能完全满足,故有时需要引入一定的近似).简单地说,问题能够分解成子问题来解决. 动态规划算法分以下4个步骤: 描述最优解的结构 递归定义最优解的值 按自底向上的方式计算最优解的值   //此3步构成动态规划解的基础. 由计算出的结果构造一个最优解.   //此步如果只要求计算最优解的值时,可省略. 好,接下来,咱们

算法学习 - 最长公共子序列（LCS）C++实现

最长公共子序列 最长公共子序列的问题很简单,就是在两个字符串中找到最长的子序列,这里明确两个含义: 子串:表示连续的一串字符 . 子序列:表示不连续的一串字符. 所以这里要查找的是不连续的最长子序列, 动态规划 这里为什么要使用动态规划可以说一下,简单来说动态规划是为了降低时间复杂度的一种算法,申请一个额外空间,来保存每一个步骤的结果,最后从这些结果中找到最优的解. 这里有个问题就是:一般来说,当前的最优解,只与当前时刻和上一时刻有关系,和其他时刻没有关系,这样才能让动态规划发生作用,降低复杂度

算法重拾之路——最长公共子序列(LCS)

***************************************转载请注明出处:http://blog.csdn.net/lttree******************************************** 第二章:动态规划 最长公共子序列 算法描述: 一个给定序列的子序列是该序列中删去若干元素后得到的序列.确切的说,若给定序列 X={ x1,x2,...,xm },则另一序列 Z = { z1,z2, ... ,zk },是X的子序列是指存在一个严格递增下标序列

算法——动态规划篇——最长公共子序列

问题描述      最长公共子序列,英文缩写为LCS(Longest Common Subsequence).其定义是,一个序列 S ,如果分别是两个或多个已知序列的子序列,且是所有符合此条件序列中最长的,则 S 称为已知序列的最长公共子序列.       解决最长公共子序列,一种常用的办法,就是穷举法,组合出所有的情况,但是这样对于长序列的情况来说,是非常不实际.. 假设现在有两个序列,x[]={'A','B','C','B','D','A','B'};y[]={'B','D','C','A'

【算法】 求最长公共子序列

最长公共子序列 算法这玩意儿我完全是外行,因为从头开始就不是这个专业的再加上从小就对逻辑性强的东西苦手..所以一直没什么机会也没什么兴趣学.去年刚开始学习了python的那段时间曾经碰到过几个算法比较高级的问题,当时觉得果然这不是我的能力能驾驭的了的..总之是先记录了下来,但是对于算法这块将来的拓展和进一步学习,其实我挺没信心的 = = 问题:最长公共子序列问题(Longest Common Sequence) 子序列是指一个字符串抽掉0到若干个字符后剩下的字符串,抽取的字符不一定相邻也不一定有

动态规划算法之：最长公共子序列 & 最长公共子串（LCS）

1.先科普下最长公共子序列 & 最长公共子串的区别: 找两个字符串的最长公共子串,这个子串要求在原字符串中是连续的.而最长公共子序列则并不要求连续. 2.最长公共子串 其实这是一个序贯决策问题,可以用动态规划来求解.我们采用一个二维矩阵来记录中间的结果.这个二维矩阵怎么构造呢?直接举个例子吧:"bab"和"caba"(当然我们现在一眼就可以看出来最长公共子串是"ba"或"ab") b a b c 0 0 0 a 0 1