DP3_最长公共子序列

using System;
namespace ConsoleApplication2
{
    public class Program
    {
        static int[,] martix;

        static string str1 = "cnblogs";
        static string str2 = "belong";

        static void Main(string[] args)
        {
            martix = new int[str1.Length + 1, str2.Length + 1];

            LCS(str1, str2);

            //只要拿出矩阵最后一个位置的数字即可
            Console.WriteLine("当前最大公共子序列的长度为:{0}", martix[str1.Length, str2.Length]);

            Console.Read();
        }

        static void LCS(string str1, string str2)
        {
            //初始化边界，过滤掉0的情况
            for (int i = 0; i <= str1.Length; i++)
                martix[i, 0] = 0;

            for (int j = 0; j <= str2.Length; j++)
                martix[0, j] = 0;

            //填充矩阵
            for (int i = 1; i <= str1.Length; i++)
            {
                for (int j = 1; j <= str2.Length; j++)
                {
                    //相等的情况
                    if (str1[i - 1] == str2[j - 1])
                    {
                        martix[i, j] = martix[i - 1, j - 1] + 1;
                    }
                    else
                    {
                        //比较“左边”和“上边“，根据其max来填充
                        if (martix[i - 1, j] >= martix[i, j - 1])
                            martix[i, j] = martix[i - 1, j];
                        else
                            martix[i, j] = martix[i, j - 1];
                    }
                }
            }
        }
    }
}

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int MAX(int a, int b)
{
    return a>b?a:b;
}
int f(char* x, char* y)
{
    if(strlen(x)==0) return 0;
    if(strlen(y)==0) return 0;
    if(*x == *y) return f(x+1,y+1)+1;
    return  MAX(f(x,y+1),f(x+1,y));
}
int main()
{
    printf("%d
", f("ac","abcd")); //2
    printf("%d
", f("acebbcde1133","xya33bc11de")); //5
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int LCSLength(char x[], char y[],int m, int n)
{
    /* 计算最长公共子序列的长度 */
    int L[m+1][n+1],i, j;
    for (i = 0; i <= m; i++) L[i][0] = 0;
    for (i = 0; i <= n; i++) L[0][i] = 0;

    for (i = 1; i <= m; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (x[i]==y[j])
                L[i][j]=L[i-1][j-1]+1;
            else if (L[i-1][j]>= L[i][j-1])
                L[i][j]= L[i-1][j];
            else
                L[i][j]= L[i][j-1];
//            if (x[i]==y[j])
//                L[i][j]=L[i-1][j-1]+1;
//            else
//            {
//                if (L[i-1][j]>= L[i][j-1])
//                    L[i][j]= L[i-1][j];
//                else
//                    L[i][j]= L[i][j-1];
//            }
        }
    }
    return L[m][n];
}
int main()
{
    char a[100] = "cnblogs";
    char b[100] = "belong";
    cout << LCSLength(a, b, strlen(a), strlen(b)) << endl;
    return 0;
}

概念：

      举个例子，cnblogs这个字符串中子序列有多少个呢？很显然有2⁷个，比如其中的cb,cgs等等都是其子序列，我们可以看出

子序列不见得一定是连续的，连续的那是子串。

分析：

既然是经典的题目肯定是有优化空间的，并且解题方式是有固定流程的，这里我们采用的是矩阵实现，也就是二维数组。

第一步：先计算最长公共子序列的长度。

第二步：根据长度，然后通过回溯求出最长公共子序列。

现有两个序列X={x₁,x₂,x_3，...x_i}，Y={y₁,y₂,y_3，....，y_i}，

设一个C[i,j]: 保存X_i与Y_j的LCS的长度。

动态规划的一个重要性质特点就是解决“子问题重叠”的场景，可以有效的避免重复计算，根据上面的公式其实可以发现C[i,j]一直保存着当前(X_i,Y_i)的最大子序列长度