最长递增子序列算法

    先贴上我看的网站，解释得特别好。

http://www.hawstein.com/posts/dp-novice-to-advanced.html

https://www.felix021.com/blog/read.php?1587

问题：设定一个序列a[9] = {2,1,5,3,6,4,8,9,7},求最长递增子序列(LIS)的长度

    方法一：DP   时间复杂度0（N*N）

     思路：1、申请一个辅助数组b[],b[i]记录到达a[i]时最长递增子序列的长度。b[]初始值都为1。

                2、求a[i]相对应的b[i]：b[i]的值等于，小于a[i]的所有a[j](j=0...i-1)所对应的b[j]中的最大的值再加上一。（我说得有点难理解）

                      b[i]=max(   if(a[j]<a[i])

                                             b[j]+1     )      (j=0~i-1)

                3、LIS的长度len初始为1，每当有b[i]>len时，更新len=b[i]。

代码：

int getLISlen(int *a,int n,int *b){
    int max=1;
    int temp=0;
    for(int i=0;i<n;i++)
    {
        b[i]=1;
        for(int j=i-1;j>=0;j--)
        {
            if(a[j]<a[i])
            {
                temp=b[j]+1;
                if(temp>b[i])
                    b[i]=temp;
            }
            if(max<b[i])
                max=b[i];
        }
    }
    return max;
}

     方法二：借助插入排序  时间复杂度（N*log(N)）

           地址我有贴，是第二个网址，该博主解释得挺清晰，我就直接贴上他的原话了。

假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7，可以看出来它的LIS长度为5。
下面一步一步试着找出它。
我们定义一个序列B，然后令 i = 1 to 9 逐个考察这个序列。
此外，我们用一个变量Len来记录现在最长算到多少了

首先，把d[1]有序地放到B里，令B[1] = 2，就是说当只有1一个数字2的时候，长度为1的LIS的最小末尾是2。这时Len=1

然后，把d[2]有序地放到B里，令B[1] = 1，就是说长度为1的LIS的最小末尾是1，d[1]=2已经没用了，很容易理解吧。这时Len=1

接着，d[3] = 5，d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5，就是说长度为2的LIS的最小末尾是5，很容易理解吧。这时候B[1..2] = 1, 5，Len＝2

再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适，因为1小于3，长度为1的LIS最小末尾应该是1，这样很容易推知，长度为2的LIS最小末尾是3，于是可以把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2

继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6, 这时B[1..3] = 1, 3, 6，还是很容易理解吧？ Len = 3 了噢。

第6个, d[6] = 4，你看它在3和6之间，于是我们就可以把6替换掉，得到B[3] = 4。B[1..3] = 1, 3, 4， Len继续等于3

第7个, d[7] = 8，它很大，比4大，嗯。于是B[4] = 8。Len变成4了

第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大，到5了。

最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道，最新的B[4] =7，B[1..5] = 1, 3, 4, 7, 9，Len = 5。

于是我们知道了LIS的长度为5。

!!!!! 注意。这个1,3,4,7,9不是LIS，它只是存储的对应长度LIS的最小末尾。有了这个末尾，我们就可以一个一个地插入数据。虽然最后一个d[9] = 7更新进去对于这组数据没有什么意义，但是如果后面再出现两个数字 8 和 9，那么就可以把8更新到d[5], 9更新到d[6]，得出LIS的长度为6。

然后应该发现一件事情了：在B中插入数据是有序的，而且是进行替换而不需要挪动——也就是说，我们可以使用二分查找，将每一个数字的插入时间优化到O(logN)~~~~~于是算法的时间复杂度就降低到了O(NlogN)～！

代码：（原博客辅助数组从1开始  下面辅助数组下标从0开始）

int insert(int b[],int m,int end,int begin){
	while(begin<end)
	{
		int mid=(begin+end)/2;
		if(b[mid]<m)
			begin=mid+1;
		else
			end=mid-1;
	}
	return begin;
}

int getLIS_len(int a[],int n,int b[]){
	int max=0;
	b[0]=a[0];
	for(int i=1;i<n;i++)
	{
		if(a[i]>b[max])
		{
			b[max+1]=a[i];
			max++;
		}
		else
		{
			int position=insert(b,a[i],max,0);
			b[position]=a[i];
		}
		
	}
	return max+1;
}

/

更新   以上只求出了最长递增子序列的长度，并没有给出具体的序列。其实序列可以根据DP数组求出来

（DP数组中 DP[i]的含义：从数组arr【0....i】，以arr[i]作为结尾数字的最大递增子序列的长度，也就是普通的DP

(方法一)中的数组b【】   注意：与方法二中的数组中b【】不同，上述的方法二，如果既记录了DP数组，又申请像

原本方法二中b【】一样的，作为折半查找的辅助数组，也可以求出具体的序列，我给出的第二种方法没有存储DP【】）

方法：从DP数组中最大的开始，例如DP【i】最大，arr【i】就是递增子序列的最后数字。然后在arr【0.....i-1】

中找j,使得（arr【j】<arr【i】）&&（DP【j】== DP【i】-1），arr[j]就是递增子序列的倒数第二位数字。依次

循环，直到DP【k】==1。

//得到arr数组中dp最大的下标
int getMax(vector<int >dp)
{
	int max = 0;
	int temp = 0;
	for(int i =0;i<dp.size();i++)
	{
		if(temp<dp[i])
		{max = i;temp = dp[i];}
	}
	return max;
}

//得到递增子序列
vector<int > getResult(vector<int >&arr,vector<int >dp)
{
	vector<int >result;
	int max = getMax(dp);
	result.push_back(arr[max]);
	for(int i = max;dp[max]>1;i--)
	{
		if(arr[i]<arr[max]&&dp[i] == dp[max]-1)
		{
			result.push_back(arr[i]);
			max = i;
		}
	}
	vector<int >re;
	for(int i = result.size()-1;i>=0;i--)
		re.push_back(result[i]);
	return re;
}