动态规划--最长递增子序列

对于一个数字序列，请设计一个复杂度为O(nlogn)的算法，返回该序列的最长上升子序列的长度，这里的子序列定义为这样一个序列U1，U2...，其中Ui < Ui+1，且A[Ui] < A[Ui+1]。

给定一个数字序列A及序列的长度n，请返回最长上升子序列的长度。

测试样例：

[2,1,4,3,1,5,6],7

返回：4

代码实现：
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>

using namespace std;

/*
函数功能：
dp[i]代表arr[i]处的最长子序列
利用数组end[],每次在end数组里面进行二分查找
把时间复杂度降为O(N*logN)
参数解释：
n：代表arr数组中数的个数
*/

int getdp(const int arr[], const int n, int dp[])
{
if (arr == NULL || n <= 0)
{
return 1;
}

int* ends = new int
;
int right = 0,i = 0;

/* l,r,mid代表ends数组二分查找时候的左右边界,和中间值 */
int l = 0, r = 0, m = 0;

ends[0] = arr[0];
dp[0] = 1;

for(i = 1; i < n; i++)
{
l = 0;
r = right;

/* 二分查找 */
while(l <= r)
{
m = (l + r) / 2;
if(arr[i] > ends[m])
{
l = m + 1;
}
else
{
r = m - 1;
}
}

/* arrp[i]在ends数组中如果找到，就替换掉该值
如果没有找到。就在ends数组后面加一个值 */
right = max(right,l);
ends[l] = arr[i];

dp[i] = l + 1;
}

delete[] ends;
return 0;
}

/* 根据dp数组找出最长的递增字串，放入incList中 */
void generateLIS(const int arr[],const int n, const int dp[],vector<int> &incList)
{
int len = 0, index = 0, i = 0;

/* 找出dp数组中最大的值，也就是最长子序列 */
for(i = 0; i < n; i++)
{
if(dp[i] > len)
{
len = dp[i];
index = i;
}
}

/* 更改incList的大小 */
incList.resize(len);
incList[--len] = arr[index];

for(i = index; i >= 0; i--)
{
if (arr[i] < arr[index] && dp[i] == dp[index] - 1)
{
incList[--len] = arr[i];
index = i;
}
}
}
int main()
{
int arrData [10] = {203,39,186,207,83,80,89,237,247,7};
int dp[10] = {0};
vector<int> vecList;
int i = 0;

getdp(arrData,10,dp);
generateLIS(arrData,10,dp,vecList);

for(i = 0; i < vecList.size(); i++)
{
cout << vecList[i] << " ";
}
cout << endl;
}