动态规划--最长上升子序列

开始接触动态规划了，从前天的枚举就把我折磨的挺痛苦的。但是，理解一道题目是让人心情愉快的。

算法是很美的，能够让人学习到很多东西的。

题目描述：

一个数的序列，其中包含一些上升子序列，求其中子序列最长的长度。

根据北大老师所讲的，他有两种分类，当然还有复杂度更低的，持续更新哦！

人人为我型：

#include "iostream.h"
#include "stdio.h"
#include "algorithm"

using namespace std;

const int MAXN=1010;
int a[MAXN];
int maxlen[MAXN];

int return_max(int a,int b)
{
	return a>b?a:b;
}

int main()
{
	int N;
	cin >>N;//输入数据长度
	for (int i=1;i<=N;i++){
		cin >>a[i];
		maxlen[i]=1;
	}

	//开始判断
	for (i=2;i<=N;i++){
		for (int j=1;j<i;j++){
			if(a[j]<a[i])
				maxlen[i]=return_max(maxlen[i],maxlen[j]+1);
		}
	}
	cout<< *max_element(maxlen+1,maxlen+N+1);
}

贴上自己的理解吧：最核心的那句的意思是，我永远找前面一个数的最长子序列个数，如果这个数比我现在这个数小，那么就+1，本来是不需要那个max函数的，只是万一我maxlen（i）比前面的一个大呢。

至于为何能够这么实现，我现在感觉动态规划其实也是一种枚举的，只是这种枚举涉及一种判断。

或者还可以这么理解第二个循环的意思是寻找第j个数字的最长子序列，更新一下之后，后面继续循环。

PS:这边的理解是分时间段写的，补充一些自己的理解。做动态规划不能按照递归的思路去做，一定从头开始：i=2开始，第一次能够更新maxlen[2]，这样maxlen[1]，maxlen[2]就都能够确定。至此再往后，我永远选择最长的嘛，我只要出现a[j]<a[i]，我就让maxlen[j]+1，理论上应该就是这么判断。可是有一种情况就是：

我第a[i]个数的最长上升子序列可能比a[j]的最长上升子序列大哎，所以使用了一个判断最大值的函数。但这种可能性不大，只是自己也没有找到反例。求网友帮忙。

我为人人型：

#include "iostream.h"  
#include "stdio.h"  
#include "algorithm"  
  
using namespace std;  
  
const int MAXN=1010;  
int a[MAXN];  
int maxlen[MAXN];  
  
int return_max(int a,int b)  
{  
    return a>b?a:b;  
}  
  
int main()  
{  
    int N;  
    cin >>N;//输入数据长度  
    for (int i=1;i<=N;i++){  
        cin >>a[i];  
        maxlen[i]=1;  
    }  
  
    //开始判断  
    for (i=1;i<=N;i++){  
        for (int j=i+1;j<=N;j++){//看看可以更新哪些值  
            if(a[j]>a[i])  
                maxlen[j]=return_max(maxlen[j],maxlen[i]+1);  
        }  
    }  
    cout<< *max_element(maxlen+1,maxlen+N+1);  
}  

来一个自己的理解：maxlen(i)代表连他自己的最长子序列，大循环是n次，接下来就是小循环，看看可以更新哪些值。我一开始停在为啥能够实现这个功能，其实是忽视了这一点，做动态规划类型的题目，不能按照递归来做，最好是从头开始：

我来详细说明吧： 从i=1开始，j往后递加，然后呢，只要a[i]<a[j]，我们认为maxlen[j]可以加1，这样maxlen[j]就能代表其最长公共子序列。以后，我也只要和它比就行。后面一个数比前面的大，就更新值。这样子可能比上面一种类型容易理解。

还有

复杂度更低的情形

以后更新.........