最长公共子串+最长公共子序列

两道题都可以用动态规划的方法做，只是状态转移方程不同。

最长公共子串（注意子串是连续的）

1、先建立一个二维数组array[str1.size()][str2.size()]（全部初始化为0），初始化第一行和第一列（元素相同处置1），然后进入状态方程

2、状态转移方程：

　　if(str1[i] == str2[i]) 　　array[i][j]=array[i-1][j-1]+1;　　（左上方对角线的值加上1）

　　否则无操作。

3、最后寻找整个array中的最大值即可（因为可能有多个子串）

示意（图中有两个公共子串，分别为"ab"和"de"，长度都为2）

程序：

/*
本程序说明：
 
最长公共子串（注意空格，不要用cin，要用getline）
 
*/
#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
int largestCommentSubString(std::string str1,std::string str2){
    if(0 == str1.length() || 0 == str2.length())
        return 0;
 
    std::vector<std::vector<int> > array(str1.size(),std::vector<int>(str2.size(),0));
    for(size_t i=0; i< str2.size(); ++i){
        if(str1[0] == str2[i])
            array[0][i]=1;
    }
    for(size_t i=0; i< str1.size(); ++i){
        if(str2[0] == str1[i])
            array[i][0]=1;
    }
    for(size_t i=1; i< str1.size(); ++i){
        for(size_t j=1; j< str2.size(); ++j){
            if(str1[i] == str2[j]){
                array[i][j]=array[i-1][j-1]+1;
            }
        }
    }
    int length=0;
    for(size_t i=0; i< array.size(); ++i){
        for(size_t j=0; j< array[0].size(); ++j){
            if(array[i][j]>length){
                length=array[i][j];
            }
        }
    }
    return length;
}
 
int main(){
    std::string str1,str2;
    while(getline(cin,str1),getline(cin,str2)){     
        cout<<largestCommentSubString(str1,str2)<<endl;
    }
    return 0;
}

最长公共子序列（注意子序列可以不连续）

1、先建立一个二维数组array[str1.size()+1][str2.size()+1]（全部初始化为0），然后进入状态方程

2、状态转移方程：

　　if(str1[i] == str2[i]) 　　array[i][j]=array[i-1][j-1]+1;　（左上方对角线的值加上1）

　　if(str1[i] != str2[i]) 　　array[i][j]=max(array[i-1][j],array[i][j-1]);　　（左边和上边的最大值）

3、最后返回整个array中的最大值即可（即array右下角元素的值）

示意(图中的公共子序列为"abde"，注意我的程序是左面的和上面的相同的情况下，优先左，当然也可以是上)：

/*
本程序说明：

最长公共子序列

*/
#include <iostream>
#include <vector>
#include <string>
using namespace std;

int findLCS(string str1,string str2) {
    // write code here
    if(0 == str1.size() || 0 == str2.size())
        return 0;
    vector<vector<int> > array(str1.size()+1,vector<int>(str2.size()+1,0));
    for(size_t i=1; i<= str1.size(); ++i){//注意：是小于等于
        for(size_t j=1; j<= str2.size(); ++j){//注意：是小于等于
            if(str1[i-1] == str2[j-1]){//前面填充了一行一列，因此判断i-1和j-1
                array[i][j]=array[i-1][j-1]+1;
                }
            else
                array[i][j]=max(array[i-1][j],array[i][j-1]);
        }
    }
    return array[str1.size()][str2.size()];
}

int main(){
    string str1,str2;
    while(getline(cin,str1),getline(cin,str2)){
        cout<<findLCS(str1,str2)<<endl;
    }
    return 0;
}

如果还要进一步打印出其中一个公共子序列的话，需要用到回溯法。我们在动态规划时需要记录元素的状态，一步步回溯回去即可。

/*
本程序说明：

最长公共子序列（加上了其中一个子序列的打印功能，回溯法）

*/
#include <iostream>
#include <vector>
#include <string>
using namespace std;

//打印（回溯法）
void printLCS(const string& str1,const string& str2,const vector<vector<string> >& flag,int i,int j,string& str)
{
    if(0==i||0==j)
        return;
    if("left_up"==flag[i][j])
    {
        str.insert(str.begin(),str1[i-1]);//把要打印的公共字符逆序存在str中(因为回溯法从后向前，所以需要逆序)
        printLCS(str1,str2,flag,i-1,j-1,str);
    }
    else if("left"==flag[i][j])
        printLCS(str1,str2,flag,i-1,j,str);
    else if("up"==flag[i][j])
        printLCS(str1,str2,flag,i,j-1,str);
}

int findLCS(const string& str1,const string& str2) {
    // write code here
    if(0 == str1.size() || 0 == str2.size())
        return 0;
    vector<vector<string> > flag(str1.size()+1,vector<string>(str2.size()+1,""));//记录状态
    vector<vector<int> > array(str1.size()+1,vector<int>(str2.size()+1,0));
    for(size_t i=1; i <= str1.size(); ++i){//注意：是小于等于
        for(size_t j=1; j<= str2.size(); ++j){//注意：是小于等于
            if(str1[i-1] == str2[j-1]){//前面填充了一行一列，因此判断i-1和j-1
                array[i][j] = array[i-1][j-1]+1;
                flag[i][j] = "left_up";
            }
            else
            {
                if(array[i-1][j] >= array[i][j-1])
                {
                    array[i][j] = array[i-1][j];
                    flag[i][j] = "left";
                }
                else/*(array[i-1][j] < array[i][j-1])*/
                {
                    array[i][j] = array[i][j-1];
                    flag[i][j] = "up";
                }
            }
        }
    }

    string str="";
    printLCS(str1,str2,flag,str1.size(),str2.size(),str);
    cout<<"公共子序列： "<<str<<endl;
    return array[str1.size()][str2.size()];
}

int main(){
    std::string str1,str2;
    while(getline(cin,str1),getline(cin,str2)){
        cout<<findLCS(str1,str2)<<endl;
    }
    return 0;
}

 最长公共子序列扩展题（注意思维的转换）：

/*
本程序说明：

给定一个数组，插入元素使得它成为回文串，要求所得回文串所有数字之和最小。

*/
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    while(cin>>n){
        vector<int> v(n);
        int sum=0;
        for(int i=0;i<n;++i){
            cin>>v[i];
            sum+=v[i];
        }

        vector<int> rv=v;
        reverse(rv.begin(),rv.end());

        //这段程序其实就是原数组和逆序数组求公共子序列，得到最大子序列的和，
        //剩下要插入的数字之和就是原数组的和减去公共子序列的和
        vector<vector<int>> dp(n+1,vector<int>(n+1,0));
        for(int i=1;i<=n;++i){
            for(int j=1;j<=n;++j){
                if(v[i-1]==rv[j-1]){
                    dp[i][j]=dp[i-1][j-1]+v[i-1];
                }
                else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }

//        for(int i=0;i<n+1;++i){
//            for(int j=0;j<n+1;++j){
//                cout<<dp[i][j]<<" ";
//            }
//            cout<<endl;
//        }

        cout<<sum+(sum-dp[n][n])<<endl;//其中sum-dp[n][n]是需要插入的数字和
    }
    return 0;
}

参考文章：http://www.cnblogs.com/huangxincheng/archive/2012/11/11/2764625.html