dp问题 线性动归入门：lis问题

最长上升子序列

最基本：n方做法 ，dp[i]表示以i结尾的最长上升子序列数量

枚举i之前的每一个下标进行比较即可

for(int i=1;i<=n;i++)
	{
		dp[i]=1;
		for(int j=1;j<i;j++)
		if(data[j]<data[i] && dp[i]<dp[j]+1)	
		dp[i]=dp[j]+1;
		
	}

这是最基础的框架，掌握这个做法有利于我们入手这一基础模型，同时是dp思想的很好体现。

只针对该问题：复杂度优化：（nlogn) 贪心的思想

在长度相同的情况下，我们当然希望目前序列的末尾越小越好，类似（2，3，4，5）和（2，3，4，6)肯定前者更优，前者我们有更大的扩展空间，因此我们改变dp[i]的含义为 （长度为i的情况下最小的序列末尾值）如上面的例子dp[4]=5;(2,3,4,5)

int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		f[i]=0x7fffffff;
	}
	f[1]=a[1];
	int len=1;
	for(int i=2;i<=n;i++)
	{
		int l=0,r=len,mid;
		if(a[i]>f[len])f[++len]=a[i];
		else 
		{
		while(l<r)
		{	
		    mid=(l+r)/2;
		    if(f[mid]>a[i])r=mid;
			else l=mid+1; 
		}//利用二分来插入
		f[l]=min(a[i],f[l]);
     	}
    }
    cout<<len;

第二种做法显然更优，但是其实第一种做法更具有普适性和可扩展性。

new problem ：

最长公共子序列问题（LCS）

1 2 3 4 5

3 2 1 4 5

ans= 3（3，4，5）

首先我们也是考虑朴素做法：

dp[i][j]表示模式串的前i位，目标串的前j位的lcs，这样的状态设置很容易得到状态方程

如果当前相同 那么

dp[i][j]=max(dp[i][j],dp[i−1][j−1]+1);

如果不相同，即无法更新公共元素，考虑继承：

dp[i][j]=max(dp[i−1][j],dp[i][j−1]）

方法二：考虑优化（nlogn）转化成求目标串的LIS

为什么呢？

A:3 2 1 4 5

B:1 2 3 4 5

我们不妨给它们重新标个号：把3标成a,把2标成b，把1标成c……于是变成：

A: a b c d e

B: c b a d e

这样标号之后，LCS长度显然不会改变。但是出现了一个性质：

两个序列的子序列，一定是A的子序列。而A本身就是单调递增的。

因此这个子序列是单调递增的。

换句话说，只要这个子序列在B中单调递增，它就是A的子序列。

哪个最长呢？当然是B的LIS最长。

自此完成转化。

#include<bits/stdc++.h>
using namespace std;
int n;
int a1[100010],a2[100010];
int belong[100010];
int f[100010],b[100010],len;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a1[i]);
        belong[a1[i]]=i;
    }
    for(int i=1;i<=n;i++)
    scanf("%d",&a2[i]);
    for(int i=1;i<=n;i++)
    {
        if(belong[a2[i]]>b[len])
        {    
            b[++len]=belong[a2[i]];
            f[i]=len;
            continue;
        }
        int k=upper_bound(b+1,b+len+1,belong[a2[i]])-b;
        b[k]=belong[a2[i]];
        f[i]=k;
    }
    printf("%d\n",len);
    return 0;
}

还有一种新的题型：最长连续不重复子序列 ，我们采用双指针算法