动态规划之最长子串匹配问题

1.问题引出

最长字段匹配问题归结如下：

假设存在两个字符段：

A={'a', 'b', 'c', 'b', 'd', 'a', 'b'};

B= {'b', 'd', 'c', 'a', 'b', 'a'};

则A、B两个字段的匹配即为A、B的公共子序列，如{‘a’}、{‘b’}、{‘b、‘d’}、{‘b’、’c’、’a’、’b’}均为该两个字符段的公共子序列，而最长公共子序列则为以上子序列中长度最长的。如{‘b’、’c’、’a’、’b’}，长度为4。

2.问题求解

2.1动态规划的简述

动态规划：把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解。通俗的解释就是将一个很大的问题转化为一个一个很小的相关联且可求解的子问题，每个子问题都可以被解决，并将结果存储，下一个子问题通过查询上一个子问题的结果进行求解，以此，只到最终问题被解决，这是一种以空间换取执行效率的方法。举例：如计算2+3，如果用动态规划的思想的话可将其分割为求1+1,1+2,2+3三个子问题，求出1+1的结果存储，求出1+2的结果存储，通过查询利用前两个子问题的结果得到2+3,算出最终结果。

2.2最长公共子序列的动态规划描述

对于上面两个子序列

A={'a', 'b', 'c', 'b', 'd', 'a', 'b'};

B= {'b', 'd', 'c', 'a', 'b', 'a'};

设两字符段的最长公共子序列result[i][j] (i为字符段A的长度，j为字符段B的长度)，

①当A[i]=B[j]时,表示该问题可规划为先找到A[i-1]与B[j-1]公共子序列值result[i-1][j-1]，result[i][j] = result[i-1][j-1]+1. 定义序列类型trace[i][j] = 1，便于后期追踪。

 ②当result[i-1][j] >= result[i][j-1]时，表示长度为i-1字段A与长度为j的字段 B的公共子序列，大于等于长度为i字段A与长度为j-1的字段 B，因此result[i][j] = result[i-1][j]; trace[i][j] = 2。

③当result[i-1][j] < result[i][j-1]时，表示长度为i-1字段A与长度为j的字段 B的公共子序列，小于长度为i字段A与长度为j-1的字段 B，此时result[i][j] = result[i][j-1]；trace[i][j] = 3。

2.3代码实现

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>

/**
* 最长公共子序列求解算法
* 
* @param lengthS1 第一个序列的长度
* @param lengthS2 第二个序列的长度
* @param s1 第一个序列头指针
* @param s2 第二个序列头指针
* @param result 最长公共子序列递推求解结果矩阵，m+1行,n+1列
* @param trace 最长公共子序列追踪矩阵，m+1行,n+1列
*/
int LCSLength(int lengthS1, int lengthS2, char* s1, char* s2, int** result, int** trace){
    int i;
    trace[0][0] = 0;  //trace[i][0]与trace[0][j]不用，可以用作标志位

    for(i=0; i<=lengthS1; i++) result[i][0] = 0;
    for(int j=1; j<=lengthS2; j++) result[0][j] = 0;

    for(i=1; i<=lengthS1; i++){
        for(int j=1; j<=lengthS2; j++){
            if(s1[i-1] == s2[j-1]) { //两个序列尾部匹配
                result[i][j] = result[i-1][j-1]+1; 
                trace[i][j] = 1;//1表示继续向左上[i-1][j-1]追踪
            } 
            else if(result[i-1][j] >= result[i][j-1]){ //当前最长序列由s1尾部前移一位与s2构成
                result[i][j] = result[i-1][j];
                trace[i][j] = 2; //2表示继续向上[i-1][j]追踪
            }
            else {  //当前最长序列由s2尾部前移一位与s1构成
                result[i][j] = result[i][j-1];
                trace[i][j] = 3;  //3表示继续向上[i][j-1]追踪
            }
        }
    }
    return result[lengthS1][lengthS2];
}

/**
* 最长公共子序列追踪构造算法
* @param tailS1 第一个序列尾部位置
* @param tailS2 第二个序列的尾部位置
* @param s1 第一个序列头指针，根据追踪矩阵在其中搜索公共子序列中字符
* @param trace 追踪矩阵
*/
void LCSTraceback(int tailS1, int tailS2, char* s1, int** trace){
    
    if  (tailS1 == 0 || tailS2 == 0) return;
    
    if  (trace[tailS1][tailS2] == 1) {  //向左上追踪[i-1][j-1]
        LCSTraceback(tailS1-1, tailS2-1, s1, trace);
        cout << s1[tailS1-1] << " ";
    }
    else if (trace[tailS1][tailS2] == 2) {  //继续向上追踪[i-1][j]
        LCSTraceback(tailS1-1, tailS2, s1, trace);
    }
    else LCSTraceback(tailS1, tailS2-1, s1, trace);
}

int main(){

    const int lengthS1 = 7, lengthS2 = 6;
    int i;
    char sequence1[lengthS1] = {'a', 'b', 'c', 'b', 'd', 'a', 'b'};
    char sequence2[lengthS2] = {'b', 'd', 'c', 'a', 'b', 'a'};

    char* s1 = sequence1;
    char* s2 = sequence2;

    cout << "s1: " << *s1;
    for(i=1; i<lengthS1; i++)
        cout << " " << *(s1 + i);
    cout<< endl;

    cout << "s2: " << *s2;
    for(i=1; i<lengthS2; i++)
        cout << " " << *(s2 + i);
    cout << endl;

    int** resultMatrix = new int* [lengthS1+1];//m+1行n+1列迭代结果矩阵
    for(i=0; i<lengthS1+1; i++)
        *(resultMatrix+i) = new int [lengthS2+1];

    int** traceMatrix = new int* [lengthS1+1];//m+1行n+1列追踪矩阵
    for(i=0; i<lengthS1+1; i++)
        *(traceMatrix+i) = new int [lengthS2+1];

    cout << "The length of the longest common sequence is: " << LCSLength(lengthS1, lengthS2, s1, s2, resultMatrix, traceMatrix) << endl;

    cout << "The longest common sequece is: " << endl;
    LCSTraceback(lengthS1, lengthS2, s1, traceMatrix);
    return 0;
}

View Code

 

 

 

转载于:https://www.cnblogs.com/zhujiangbk/p/3720130.html