最长公共子序列、上升子序列、最长上升子序列、最长公共子串

最长公共子序列

其实有很多方法可以过，因为在弄DP所以就只写了动态规划的方法：

动态规划方法

1、序列str1和序列str2

    ·长度分别为m和n；

    ·创建1个二维数组L[m.n]；

    ·初始化L数组内容为0

    ·m和n分别从0开始，m++，n++循环：

    - 如果str1[m] == str2[n]，则L[m,n] = L[m - 1, n -1] + 1；

    - 如果str1[m] != str2[n]，则L[m,n] = max{L[m,n - 1]，L[m - 1, n]}

    ·最后从L[m,n]中的数字一定是最大的，且这个数字就是最长公共子序列的长度

    ·从数组L中找出一个最长的公共子序列

2、从数组L中查找一个最长的公共子序列

    i和j分别从m，n开始，递减循环直到i = 0，j = 0。其中，m和n分别为两个串的长度。

    ·如果str1[i] == str2[j]，则将str[i]字符插入到子序列内，i--，j--；

    ·如果str1[i] != str[j]，则比较L[i,j-1]与L[i-1,j]，L[i,j-1]大，则j--，否则i--；（如果相等，则任选一个）

根据上图，我们可以得到其中公共子序列：B C B A 和 B D A B。

# include <map>
# include <queue>
# include <stack>
# include <math.h>
# include <stdio.h>
# include <string.h>
# include <iostream>
# include <algorithm>
# define N 510
using namespace std;

char s1[N], s2[N];
int dp[N][N];

int max(int x, int y)
{
    if(x > y)
        return x;
    else
        return y;
}

int main(void)
{
    while(gets(s1))
    {
        gets(s2);
        int len1 = strlen(s1);
        int len2 = strlen(s2);
        for(int i = 0; i <= len1; i++)
            for(int j = 0; j <= len2; j++)
                dp[i][j] = 0;
        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
                {
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        printf("%d
", dp[len1][len2]);
    }

    return 0;
}

很好的一篇介绍LCS的文章http://blog.csdn.net/v_july_v/article/details/6695482

最长上升子序列 

# include <map>
# include <queue>
# include <stack>
# include <math.h>
# include <stdio.h>
# include <string.h>
# include <iostream>
# include <algorithm>
# define N 1010
using namespace std;

int a[N], dp[N];

int main(void)
{
    int n, m, i, j;
    scanf("%d", &n);
    for(i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    dp[1] = 1;
    for(i = 2; i <= n; i++)
    {
        m = 0;
        for(j = 1; j < i; j++)
        {
            if(a[i] > a[j] && m < dp[j])
                m = dp[j];
        }
        dp[i] = m+1;
    }
    int nMax = -1;
    for(i = 1; i <= n; i++)
    {
        if(nMax < dp[i])
            nMax = dp[i];
    }
    printf("%d
", nMax);

    return 0;
}

上升子序列（最长上升子序列改版  求和）

# include <map>
# include <queue>
# include <stack>
# include <math.h>
# include <stdio.h>
# include <string.h>
# include <iostream>
# include <algorithm>
# define N 1010
using namespace std;

int a[10000], dp[10000];
int main(void)
{
    int n, max, i, j;
    while (~scanf("%d",&n))
    {
        for (i = 0; i < n; i++)
            scanf("%d", &a[i]);
        dp[0] = a[0];
        for (i = 0; i < n; i++)
        {
            max = 0;
            for (j = 0; j < i; j++)
            {
                if (a[i] > a[j])
                {
                    if (max < dp[j])
                        max = dp[j];
                }
            }
            dp[i] = a[i] + max;
        }
        int t = 0;
        for (i = 0; i < n; i++)
        {
            if (t < dp[i])
                t = dp[i];
        }
        printf("%d
", t);
    }

    return 0;
}

最长公共子串

# include <stdio.h>
# include <string.h>

int dp[30010], n, t;
char c[101], len[101], a[101][101];     /* 这里存储着状态数列, 长度 */

int get(int i, int k)                    /* 得到状态 */
{
    if (i > n)
        return 0;
    return get(i+1, k*len[i]) + k * c[i];
}

int LCS()
{
    int p, i, j;
    p = get(0, 1);
    if (!dp[p])
    {
        for(i = 1; i <= n-1; i++)
            if (a[i][c[i]] != a[i+1][c[i+1]])
                break;
        if (i > n - 1)
        {
            for(i=1; i<=n; ++i)
            {
                if (c[i])
                    c[i]--;
                else
                    break;
            }
            if (i > n)
            {
                j = LCS() + 1;
                if (j >= dp[p])
                    dp[p] = j + 1;
            }
            else
            {
                dp[p] = 2;
            }
            while((--i)>0)
            {
                c[i]++;
            }
        }
        else
        {
            for(i = 1; i <= n; i++)
            {
                if(c[i])
                {
                    c[i]--;                /* 遍历前一个状态 */
                    j = LCS();
                    if (j >= dp[p])
                        dp[p] = j + 1;
                    c[i]++;
                }
            }
            if (!dp[p])
                dp[p] = 1;
        }
    }
    return dp[p] - 1;
}

int main(void)
{
    int i;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        memset(dp, 0, 30000*sizeof(dp[0]));
        len[0] = 1;
        for(i = 1; i <= n; i++)
        {
            scanf("%s", a[i]);
            len[i] = strlen(a[i]);
            c[i] = len[i] - 1;
        }
        printf("%d
", LCS());           /* 进行倒推 */
    }
}

公共字串理解的还不是很深刻  留代码= =、