HDU 1423 最长公共字串+上升子序列

http://acm.hdu.edu.cn/showproblem.php?pid=1423

在前一道题的基础上多了一次筛选

要选出一个最长的递增数列

lower_bound()函数很好用，二分搜索找出满足ai>k的ai最小指针

还有upper_bound()

头文件#include<algorithm>

比如求长度为n的数组a中k的个数：upper_bound(a,a+n,k)-lower_bound(a,a+n,k)

int 放在main函数里面声明会出现程序崩溃，放在全局就没有问题，这里不知原因

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
int i,j,n,m,h,a,b;
int s[],t[],lable[][],dp[][];
int ai[],dpp[];
void mem()
{
    memset(s,,sizeof(s));
    memset(t,,sizeof(s));

    memset(ai,,sizeof(s));
    memset(dpp,,sizeof(s));
    for(i=;i<;i++)
    {
        memset(dp[i],,sizeof(s));
        memset(lable[i],,sizeof(s));
    }
}
int main()
{
    int NN;
    scanf("%d",&NN);
    while(NN--)
    {
        mem();
        scanf("%d",&n);
        for(i=;i<n;i++)
        {
            scanf("%d",&s[i]);
        }
        scanf("%d",&m);
        for(i=;i<m;i++)
        {
            scanf("%d",&t[i]);
        }
        for(i=;i<n;i++)
        {
            for(j=;j<m;j++)
            {
                if(s[i]==t[j])
                {
                    dp[i+][j+]=dp[i][j]+;
                    lable[i+][j+]=;
                }
                else
                {
                    if(dp[i][j+]>dp[i+][j])
                    {
                        dp[i+][j+]=dp[i][j+];
                        lable[i+][j+]=;
                    }
                    else
                    {
                        dp[i+][j+]=dp[i+][j];
                        lable[i+][j+]=;
                    }
                }
            }
        }
        a=n;b=m;
        h=dp[n][m];
        while(lable[a][b]!=)
        {
            if(lable[a][b]==)
            {
                a--;b--;h--;
                ai[h]=s[a];//or t[b]
            }
            else if(lable[a][b]==)
            {
                a--;
            }
            else if(lable[a][b]==)
            {
                b--;
            }
        }
        fill(dpp,dpp+n,INF);
        h=dp[n][m];
        for(i=;i<h;i++)
        {
            *lower_bound(dpp,dpp+h,ai[i])=ai[i];
        }
        cout<<lower_bound(dpp,dpp+n,INF)-dpp<<endl;
        if(NN) cout<<endl;
    }
    return ;
}