最长递增子序列

程序员代码面试指南：最长递增子序列，给定数组arr，返回其最长递增子序列。

动态规划：生成数组dp， dp[i]表示以arr[i]结尾的最长子序列的长度。dp[0] = 1，dp[i]=max{dp[j]+1, j < i, arr[j] < arr[i]}。

从dp中得到最大值即为最长子序列的长度，其下标对应的arr中的值即为子序列的最后一个值。从该值开始向前遍历，如果前面一个值满足arr[j]<arr[i]且dp[j]==dp[i] -1，则该值也是子序列的值，循环向前遍历。、

C++实现：

void getDP(int *arr, int *dp, int len)
{
    for (int i = 0; i < len; i++)
    {
        dp[i] = 1;
        for (int j = 0; j < i; j++)
        {
            if (arr[j] < arr[i] && (dp[j] + 1) > dp[i])
            {
                dp[i] = dp[j] + 1;
            }
        }
    }
}

void generateLIS(int *arr, int arrLen, int *dp, int dpLen, int *lis, int& lisLen)
{
    int index = 0;
    int len = 0;
    for (int i = 0; i < dpLen; i++)
    {
        if (dp[i] > len)
        {
            len = dp[i];
            index = i;
        }
    }

    lisLen = len;
    lis[--len] = arr[index];
    for (int i = index - 1; i >=0; i--)
    {
        if (arr[i] < arr[index] && dp[i] == dp[index] - 1)
        {
            lis[--len] = arr[i];
            index = i;
        }
    }
}

void getLIS(int *arr, int len, int *lis, int& lisLen)
{
    if (NULL == arr || NULL == lis)
    {
        return;
    }

    int *dp = new int[len];
    getDP(arr,dp,len);

    generateLIS(arr,len,dp,len,lis,lisLen);

    delete[] dp;
}


int main(int argc, char* argv[])
{
    int arr[] = {2,1,5,3,6,4,8,9,7};
    int len = sizeof(arr)/sizeof(arr[0]);
    int *lis = new int[len];
    
    getLIS(arr,len, lis,len);
    for (int i = 0; i < len; i++)
    {
        printf("%d ", lis[i]);
    }
    printf("\n");
    delete[] lis;
    return 0;
}

该算法复杂度为O(N2)，如果有多个最长子序列，只是输出了其中一个。