洛谷 P1439 【模板】最长公共子序列

解法一：

#include<bits/stdc++.h>
using namespace std;
int b[100010],c[100010];
int dp[10000][10000];
int main()
{
int n;
cin>>n;


for(int i=1;i<=n;++i){
    scanf("%d",b+i);


}


for(int i=1;i<=n;++i){
    scanf("%d",c+i);



}



for(int i=1;i<=n;++i)
    for(int j=1;j<=n;++j){

            if(b[i]==c[j])
               dp[i][j]=dp[i-1][j-1]+1;

            else
               dp[i][j]=max( dp[i-1][j],dp[i][j-1]);



    }

cout<<dp[n][n];


return 0;
}

有一半超时了

解法二：

#include<bits/stdc++.h>
using namespace std;
int b[100010],c[100010];
int dp[100010];
int main()
{
int n;
cin>>n;
int x;

for(int i=1;i<=n;++i){
    scanf("%d",&x);
    c[x]=i;

}


for(int i=1;i<=n;++i){
    scanf("%d",&x);
    b[i]=c[x];



}









for(int i=1;i<=n;++i){
    int ma=0;
    for(int j=1;j<=i-1;++j)
        if(b[j]<b[i]&&dp[j]>ma)
            ma=dp[j];

    dp[i]=ma+1;



}

int ma=1;
for(int i=1;i<=n;++i)
    if(dp[i]>=ma)
       ma=dp[i];

cout<<ma;
return 0;
}

10个样例，4个超时

运用所谓映射，其实也就和ASCII码一样，给每一个数编一个唯一的码，比如‘0’的ascii码是48，我们用的时候就用48，48就能代表 ‘0’，但是不用 ’ 0 '来操作，而是用48来操作，如果另一个字符的编码是48，那这个字符就必定和 ‘0’是相等的。如果两个数的编码相等，那么这两个数就相等。

回到题目，把两组数都转化成编码，只要编码相等，原数就相等。这里直接把1到n的编码顺次给第一组数，，再按编码方式把第二组数转化为编码。第一组编码为1，2，3，。。。，n， 所以只要求第二组编码的最大上升子序列。

解法三（ac代码）
就把解法二的找最小上升子序列改成效率更高（nlogn）的方法

nlogn的算法可行的原因搜到的都 tm 不讲清楚，只可意会不可言传 ？真tm，真懂？

#include<bits/stdc++.h>
using namespace std;
int b[100010],c[100010];
int dp[100010];



int bisearch(int l,int r,int x){

    if(l==r)
        return l;



   int mid=(l+r)/2;

   if(x<dp[mid])
    return bisearch(l,mid,x);

   else
     return bisearch(mid+1,r,x);




}


int main()
{
int n;
cin>>n;
int x;

for(int i=1;i<=n;++i){
    scanf("%d",&x);
    c[x]=i;

}


for(int i=1;i<=n;++i){
    scanf("%d",&x);
    b[i]=c[x];



}






dp[1]=b[1];

int maxlen=1;

for(int i=1;i<=n;++i){
        if(b[i]>dp[maxlen])
          dp[++maxlen]=b[i];

        else{
            int k=bisearch(1,maxlen,b[i]);

            dp[k]=b[i];



        }


}


cout<<maxlen;
return 0;
}

ac 了啊啊啊
一把辛酸泪，下饭

1.优化了是因为用了二分搜索。
2.这里dp数组是个很奇怪的东西，dp[i]=x 是指当前长度为 i 的上升子序列，这个子序列最后一个数为x。奇怪在于dp数组必是一个递增序列。递增使得二分搜索可以用。
3.逻辑上操作方法：
遍历数组，使 长度为 i 的 上升子序列 的 最后一个元素 在当前是最小的

4.代码实际操作
遍历数组，其实就是把数一个一个的放在要判断的序列里，当前的思想。每加入一个数x，通过二分搜索找到位置k，使得dp[k-1]<x<dp[k] ,(如果k是最开始的位置，满足x<dp[k] ),
dp[k]=x

5.为啥是这样（说起来太麻烦了，啊啊啊啊）

dp数组中的每一个数，都代表了一个上升子序列，而且是用这个序列的最后一个数来代表这个上升子序列

首先 假设在某一个状态，dp数组只是递增的序，除此之外，没有任何意义，我新加入一个数x，找到位置k（ dp[k-1]<x<dp[k] ），dp[k]=x, ，dp[1]到dp[k]是一个递增序列，这个操作就让这段子序列的最后一个数缩小了。然后我又在之后的某一次循环，加入一个y，这个y是满足 dp[k]<y<dp[k+1]，假设之前的x很小很小，so little，原来的dp[k]很大很大很大，y是一个适中的数，，，x 替换了原来的dp[k]，就使得y的位置可以在k和k+1之间。
神奇的转折来了，
由于上面的操作，已经找到了一个长度为k的子序列，子序列具体是啥我不管，但是***最后一个数是x, 而此时 y>x,那我y加入你这个子序列里就是k+1的长度了啊，所以dp[k+1]=y，而且我y小于你原来的dp[k+1]，也更新了长度为k+1的子序列的最后一个数（让她变小）***

dp[k-1]代表了一个长度为k-1的上升子序列，因 dp[k-1]<x ，把x加入这个子序列中，就得到了长度为k的上升子序列，来替换原来 长度为k的上升子序列

由于这个插入方式，也就决定了dp数组必然始终是一个递增数组

dp[maxlen]一视同仁，该更新就给我更新，你自然是最新鲜的状态。这时，如果来个妹子z，比dp[maxlen]还要大。再啰嗦一边，dp[maxlen]由于上面的操作，保证了长度为maxlen的子序列一定存在，但我早就弄丢了它，知道它存在就行。这时候妹子z就把这个子序列复制过来，然后自己加进去，变成了长度为maxlen+1