算法 : 最长升序降序序列

引用 ：算法:最长升序降序序列，7 5 6 8 10 7 9 3 8 7 4 1 8 9 4，则最长的升序序列为5, 6, 8,
10，最长的降序序列为8,7,4,1

看了一些网上的资料，最长的升序/降序 好像不是非要在彼此挨着的吧？

最长的升序序列 不可以为 ：5 6 7 8 9 吗？

最长的降序序列 不可以为 ：10 9 8 7 4 1 吗？



引用：Lifeng Wang
主动去创造环境，否则你无法设计人生

个人C++ 没学过，C#倒很熟悉，C嘛，大一学到指针就结课了，后面一些除了校门用得更多的东西反倒没学，悲哀啊。

再加上本人有点笨，还是看不懂 什么 时间和空间复杂度的 问题啊。。。。想学算法，还真 不容易啊。。。还望高手指点。



一、算法思想




算法还是容易想到的，两
重循环
DP

即可。不过
如果数据规模最大可以达到几十万甚至更大
，经典的
O(n^2)

的动态规划算法明显会超时。我们需要寻找更好的方法来解决是最长上升子序列问题。以
下以最长递增子序列为例进行说明：

　

　先回顾经典的
O(n^2)

的动态规划算法，设
A[i]

表示序列中的第
i

个数，
F[i]

表示从
1

到
i

这一段中以
i

结尾的最长上升子序列的长度，初始时设
F[i] = 0(i = 1, 2, ..., len(A))

。
则有动态规划方程：
F[i] = max{1, F[j] +
1} (j = 1, 2, ..., i - 1,

且
A[j] < A[i])

。

　　现在，我们仔细考虑计算
F[i]

时的情况。假设有两个元素
A[x]

和
A[y]

，满足
(1)x < y < i (2)A[x] < A[y] < A[i]
(3)F[x] = F[y]

　　此时，选择
F[x]

和选择
F[y]

都可以得到同样的
F[i]

值，那么，在最长上升子序列的这个位置中，应该选择
A[x]

还是应该选择
A[y]

呢？

　　很明显，选择
A[x]

比选择
A[y]

要好。因为由于条件
(2)

，在
A[x+1] ... A[i-1]

这一段中，如果存在
A[z]

，
A[x] < A[z] < a[y]

，则与选择
A[y]

相比，将会得到更长的上升子序列。

　　再根据条件
(3)

，我们会得到一个启示：根据
F[]

的值进行分类。对于
F[]

的每一个取值
k

，我们只需要保留满足
F[i] = k

的所有
A[i]

中的最小值。设
D[k]

记录这个值，即
D[k] = min{ A[i] } ( F[i] = k )

。

　　注意到
D[]

的两个特点：

　　
(1)

　
D[k]

的值是在整个计算过程中是单调不上升的。
//

此处需要特别注意
!!!

关键之所在
!

　　
(2)

　
D[]

的值是有序的，即
D[1] < D[2] < D[3] < ... < D

。

利用
D[]

，我们可以得到另外一种计算最长上升子序列长度的方
法。设当前已经求出的最长上升子序列长度为
len

。
先判断
A[i]

与
D[len],

若
A[i] > D[len]

，则将
A[i]

接在
D[len]

后将得到一个更长的上升子序列
,len = len + 1,D[len+1] = A[i];

否
则
,

在
D[1]..D[len]

中
,

找到最大的
j,

满足
D[j] < A[i].

令
k = j + 1,

则有
D[j] < A[i] <= D[k]

，将
A[i]

接在
D[j]

后将得到一个更长的上升子序列
,

同时更新
D[k] = A[i].

最后，
len

即为所要求的最长上升子序列的长度。

　　在上述算法中
,

若使用朴素的顺序查找在
D[1]..D[len]

查找
,

由于共有
O(n)

个元素需要计算
,

每次计算时的复杂度是
O(n),

则整个算法的时间复杂度为
O(n^2),

与原来的算法相比没有任何进步
.

但是由于
D[]

的特点
(2),

我们在
D[]

中查找时
,

可以使用二分查找高效地完成
,

则整个算法的时间复杂度下降为
O(nlogn),

有了非常显著的提高
.

需要注意的是
,D[]

在算法结束后记录的并不是一个符合题意的最长上升子序
列
.

这
个算法还可以扩展到整个最长子序列系列问题
,

整
个算法的难点在于二分查找的设计
,

需
要非常小心注意
.

二、
实现


// By Fandywang
2008.7.21

// Call: LIS(a,
n);
求最大递增/
上
升子序列(
如果为最大非降子序列,
只需把上面的注释部分给与替换)

const
int
N =
1001;

int

a
, f
, d
; // d[i]

用于记录a[0...i]
的最大长度

int
bsearch(const
int
*f, int
size, const
int
&a)

{


int

l=0, r=size-1;


while
( l <= r )


{


int

mid = (l+r)/2;


if
( a > f[mid-1] && a <=
f[mid] ) return
mid; // >&&<=

换为: >= && <


else
if
( a
< f[mid] ) r = mid-1;


else
l = mid+1;


}

}

int
LIS(const
int
*a, const
int
&n){


int

i, j, size = 1;


f[0]
= a[0]; d[0] = 1;


for
( i=1; i < n; ++i ){



if
( a[i] <=
f[0] ) j = 0;
// <=

换为: <


else
if
(
a[i] > f[size-1] ) j = size++;
// >

换为: >=


else
j = bsearch(f, size, a[i]);


f[j]
= a[i]; d[i] = j+1;


}


return
size;

}

三、
学以致用


JOJ 1829
Candies



最大非下降子序列

JOJ 2162
Inuyasha And the Monsters



求和最大的非
下降子序列
(

这个我
用的是
O(n^2)

的
算法做的
,

居然还那个
了第一
...)

JOJ 2529
Chorus



最
大上升子序列
+

最大下
降子序列

JOJ 1048
Wooden Sticks



先自定义排下序
(

先按
l

从
小到大
, l

相等再按
w

从小到大
),

然后求
w

的最大下降子序列

POJ 3636
Nested Dolls



与
JOJ1048

类
似

w

从
小到大
,w

相等
h

从大到小
,

然后求
h

最大非升子序列


p.s.:
如果有不准确地方欢迎指出，如果有更好的处理，麻烦教我，多多交流！~