DP，三，LIS和LCS

一，O(n^2)

LCS：HDU1159

最长公共子序列模板，求两个字符串的最长公共子序列

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
char a[10005],b[10005];
int dp[1005][1005];
int main()
{
	int i,j;
	while(cin>>a){
		cin>>b;
		int La=strlen(a),Lb=strlen(b);
		memset(dp,0,sizeof(dp));
		for(i=1;i<=La;i++){
			for(j=1;j<=Lb;j++){
				if(a[i-1]==b[j-1])dp[i][j]=dp[i-1][j-1]+1;
				else {//a[i-1]==b[j-1],下标从0开始的。
					if(dp[i-1][j]>dp[i][j-1])//相同时就加一
						dp[i][j]=dp[i-1][j];//不同的时候
					else dp[i][j]=dp[i][j-1];
				}
			}
		}
		cout<<dp[La][Lb]<<endl;
	}
	return 0;
}

两个一维数组优化（感觉没什么卵用，就是能把数组长度加大一点）

#include<iostream>
#include<cmath>
#include<map>
using namespace std;
int dp[10005],pre[10005];//pre记录上一行
int main()
{
	char a[1005],b[1005];
	int i,j,La,Lb;
	while(scanf("%s%s",a,b)==2){
		La=strlen(a);Lb=strlen(b);
		memset(dp,0,sizeof(dp));
		memset(pre,0,sizeof(pre));
		for(i=1;i<=La;i++){
			for(j=1;j<=Lb;j++){//dp数组从1到Lb
				if(a[i-1]==b[j-1]){//字符数组从0到Lb-1
					if(dp[j]<pre[j-1]+1)
						dp[j]=pre[j-1]+1;
				}
				else{
					if(dp[j-1]>pre[j])
						dp[j]=dp[j-1];
					else dp[j]=pre[j];//选左边和上边大的一个
				}
				pre[j-1]=dp[j-1];//pre更新为这一行
			}
			pre[Lb]=dp[Lb];//手动写最后一个字符
		}
		cout<<dp[Lb]<<endl;
	}
	return 0;
}
			

 

LIS：

 Longest Ordered Subsequence

最长上升子序列

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int dp[10005], a[1005];
int main()
{
	int n, i, j;
	while (scanf("%d", &n) == 1) {
		for (i = 0; i < n; i++)
			scanf("%d", &a[i]);
		memset(dp, 0, sizeof(dp));
		for (i = 1; i < n; i++) 
		{
			for (j = 0; j < i; j++)
			{
				if ((a[i] > a[j])&&(dp[i]<dp[j]+1))//保证严格的上升,状态转移
				dp[i] = dp[j] + 1;
			}
		}
		int max = -1;
		for (i = 0; i < n; i++)
			if (max < dp[i])
				max = dp[i];
		cout << max + 1 << endl;
	}
	return 0;
}

二n*lgn

LIS

hdu5773

有一个数组，其中0可以变为任何数字，其他数字都是正整数，问最长上升子序列

先把0剔除，并且计算0的个数。

1：当 0两边的数字之差比0的个数大的时候，比如：1 0 0 0 7 3 ，就可以把中间的0换成2到6的数字，把0剔除后，算出1 7 3的LIS，再直接加上0的个数就行。

2：当0两边的数字之差小于等于0的个数的时候，比如2 3 0 0 0 4 1 ，就把0后面的数字减去0的个数，剔除0后，得到2 3 1 -2，

求出LIS，保证序列单调递增，（减去0的个数后的LIS明显会更小），最后再加上0的个数。  

当 0两边的数字之差比0的个数大的时候，我们也把0后面的数字减去0的个数，1 0 0 0 7 3，变为 1 4 0，再求LIS，只是这时候的LIS不会发生变化。

由于数据很大，要用n*logn的算法。这个博客讲得很清楚

最后要注意的就是：需要判

断全为0的情况，特别要注意边界条件的判定，有时wa就是这个原因。

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
long long a[100005],b[100005],dp[100005];
int main()
{
    long long T,n,i,j,zer,k,cas=0,ind;
    cin>>T;
    while(T--)
    {
        scanf("%lld",&n);
        zer=0;j=0;
        for(i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            if(a[i]==0)zer++;
            else b[++j]=a[i]-zer;
        }
        if(zer==n)ind=0;
        else 
        {
            ind=1;dp[1]=b[1];
        }
        for(i=2;i<=j;i++)
        {
            if(b[i]>dp[ind])dp[++ind]=b[i];
            else
            {
                long long temp=lower_bound(dp+1,dp+ind+1,b[i])-dp;
                dp[temp]=b[i];
            }
        }
        cout<<"Case #"<<++cas<<": ";
        cout<<ind+zer<<endl;
    }
    return 0;
}