最长上升子序列的解法及其路径输出

前言

首先，这是是一篇萌新教程，顾名思义，这是一篇萌新写个小萌新的教程，先告知一下了。
感谢一下17级的骆兴程师哥，这篇文章是基于他的课件写的，而且我的LIS也是他教的。
因为我也是才刚刚学会LIS的解法，我写这一片博客一是帮助之后学习这个的同学，也是为了巩固一下自己对于LIS的理解，若有什么问题和错误，希望大家可以指出来，谢谢。

最长上升子序列解法

最长上升子序列（Longest Increasing Subsequence,LIS）是一个数列中最长的（非）严格上升的子序列， LIS的求解是DP思想的经典体现。
LIS求解有两种方法，分别是n ^ 2解法和n * logn解法。

n ^ 2解法

n ^ 2算法求解长度为n数列的LIS时， 是通过求前 n- 1, n-2, …, 2, 1个数的LIS递推完成的。也就是说这个方法会枚举出所有可能，并得出最大解，通俗易懂。
先定义一个数组s[9]={1,6,3,4,7,8,2,4,9}和一个dp[i]来做解释。
从前两个数开始看（一个数的情况不用去看），6比1大，所以1、6是一个LIS，那么dp[1]=2，代表当数列到此为止时，最长为2。而第三个数3比6小，那么到3为止，LIS可以是1、6，也可以是1、3，我们不需要去管他那个更优，还是dp[2]=2，到第四个数4,4比6小，但是比3大，也就是说4可以加在1、3之后，那么到4为止，最长就是3了，dp[3]=3。以此类推，就可枚举出所有情况。
附上代码：

int ans=0;
for(i=1; i<N; i++) //长度从 2 开始计算
{
    dp[i]=1;//初始化为1
    for(j=0; j<i; j++) //枚举前i-1个数来寻找dp[i]的最大值
    {
        if(s[j]<s[i])
            dp[i]=max(dp[i], dp[j]+1);//dp数组中的数代表着到这个数LIS的长度
    }
}
for(i=0; i<x; i++)
        if(maxx<num[i])
            maxx=num[i];//循环dp找出最大数，就是LIS的长度
            

n * logn解法

个人认为n * logn解法比起n ^ 2解法在方法上更加的易懂，但是原理上的理解则要难一些。因为n ^ 2解法是用枚举进行计算的，那么所有情况无论是不是LIS都是准确的，但是n * logn解法所存下的数列却是错误的，我知道初学者可能听得有点云里雾里，没有关系，我们先讲一下做法。
初始时dp[0] = s[0]， 从i = 1时遍历原数列， 将每个数与dp数列的末尾的数进行比较， 如果大于末尾的数， 就把s[i]放在dp数列的最后， 如果小于末尾的数，那么就用s[i]替换掉dp中第一个比s[i]大的数。
最后dp数列的长度就是LIS的长度，但是要注意dp中的数不是LIS的元素。
还是先定义s[9]={1,6,3,4,7,8,2,4,9}和dp[i]，第一个数1直接放入dp中，第二个数6比1大，把6放在1后面，此时的数列是1、6。第三个数3比6小，于是去查找dp中第一个比3大的数字，也就是6，替换成3，此时的dp为1、3。第四个数4又比最后一个数3大，放入dp末尾…以此类推，可以很快得出dp最后的情况：1、2、4、4、8、9。但是正确答案应该是1、3、4、7、8、9.长度确实一样，但是dp内的元素是错误的，我们结合代码理解一下。

dp[0] = s[0];
len = 0;
for(i = 1; i < N; i++)
{
    if(s[i] > dp[len])
        dp[++len] = s[i];//加在数列的最后
    else 
        *lower_bound(dp, dp+len, s[i])=s[i];//用二分法找dp中第一个大于s[i]的数，要是不会用循环也是可以的。
}
len++;

len就是我们要求的LIS的长度。
从LIS的性质出发，要想得到一个更长的上升序列，该序列前面的数必须尽量的小，有点贪心的思想。就像样例数列里一开始是1、6，但是我们可以用更小的3去代替6，使数列整体变小以实现最优解。

最长上升子序列的路径输出

我个人而言，LIS只要搞懂了求法，路径输出其实是很简单的。

n ^ 2路径输出

n ^ 2解法已经枚举了所有的情况，而且你会发现在第i个数是基于i-1个数求出来的，那么不难想到定义一个结构体，把上一位的下标储存在这一位里，然后逆向输出，和BFS的路径输出颇为相似。

struct LIS
{
    int s, pre, dp=1;//s,dp就是之前的两个数组，而pre则是储存上一位下标的
} ans[N];
for(i=0; i<N; i++)
{
    maxx=0, pos;//pos用来记录最长递增子序列的末尾数字下标
    for(j=0; j<i; j++)
    {
        if(ans[j].s<ans[i].s)
        {
            ans[i].dp=max(ans[j].dp+1, ans[i].dp);
            ans[i].pre=j;
            if(maxx<ans[i].dp)
            {
                maxx=ans[i].dp;
                pos=j;
            }
        }
    }
}

此时pos中储存的便是LIS最后一个元素的下标，然后在一层一层往前找就可以了。输出就不再写了。

n * logn路径输出

n * logn的解法中，正确的LIS不会被存储下来，没有正确的路径，自然不能用和上面一样的方法输出。我们采取一种曲线救国的方法，不难发现，在n * logn解法中，每一个数都会在dp数列中出现，且如果这个数在最后的LIS中，那么该数在dp中出现的位置和LIS中的位置是一样的。通过逆序检索，便可找出LIS每个位置上应该有的正确的数。
附上代码：

dp[0]=s[0];
len=1;
pos[0]=len;
for(i=1; i<N; i++)
{
    if(s[i]>dp[len])
    {
        dp[++len]=s[i];
        pos[i]=len;//记录s[i]在dp数组中出现的位置
    }
    else
    {
        int m=lower_bound(dp+1, dp+len+1, s[i])-dp;
        dp[m]=s[i];
        pos[i]=m;
    }
}
for(i=N-1; i>=0; i--)
{
    if(!len)
        break;
    if(pos[i]==len)
    {
        ans[len]=i;
        len--;
    }
}

最长下降子序列

这里再插一句最长下降子序列的问题的求解，我一开始碰到的最长下降子序列题就是求子序列的长度，我便把原数列翻转，求最长上升子序列，当然答案是没有问题的。
可是当我碰到一道特殊题我便发现这个方法怎么也过不了，之后便想了想，发现最长下降子序列其实非常简单，只要把dp[i]<s[i]这个条件改成dp[i]>s[i]就ok了，其实也没什么东西。而且在从大到小的数列中，lower_bound查找的是第一个小于或等于num的数字，也完全可以使用（感谢帅帅的舍友，我原来还不知道可以这么用）。

发一个我们学校上oj的题，感觉挺好的，新手可以练练手。
1040.导弹拦截 链接: link.
附上我的解题思路：链接: link.

最后再次感谢17级的骆兴程师哥和耐心看完本文的各位。