拿POJ 2533来说。

Sample Input

7
1 7 3 5 9 4 8

Sample Output(最长上升/非降子序列的长度)

4

从输入的序列中找出最长的上升子序列(LIS)。

这题一看,是一道典型的DP问题(就是动态规划),可以用dfs,深度优先遍历来解,如下代码:

#include<iostream>
#include
<stack>
using namespace std;

int n;
int* a;
stack
<int> s;
int count=0;
int best=0;

void dfs(int i)
{
if(i==n)
{
if(s.size()>best) best=s.size();
return;
}
if(s.empty()||a[i]>s.top())
{
s.push(a[i]);
dfs(i
+1);
s.pop();
}
if(s.size()+n-i-1>best) dfs(i+1);
}

int main()
{
while(cin>>n)
{
int i;
a
=new int[n];
for(i=0;i<n;i++)
{
cin
>>a[i];
}
dfs(
0);
cout
<<best<<endl;
delete [] a;
}
return 0;
}

  其实为了简化代码以及算法效率,我们可以用数据组来代替递归。。。下面我就给出LIS的DP的数据组形式的解法:

(懒得写了,就拿个别人的代码来展示吧)

#include <iostream>
#define SIZE 1001

using namespace std;

int main()
{
int i, j, n, max;
/* a[i]表示输入第i个元素 */
int a[SIZE];
/* d[i]表示以a[i]结尾的最长子序列长度 */
int d[SIZE];

while(cin >> n)
{
for (i = 1; i <= n; i++)
{
cin
>> a[i];
}

max
= 0;
for (i = 1; i <= n; i++)
{
d[i]
= 1;
for (j = 1; j <= i - 1; j++)
{
if (a[j] < a[i] && d[i] < d[j] + 1) //这边,要注意 d[i] < d[j] + 1这个条件的限制,它是为了在
//连续几个 d[i]相同时 只加一次
{
d[i]
= d[j] + 1;
}
}
/* 记录最长子序列 */
if (d[i] > max) max = d[i];
}

cout
<< max << endl;
}

//system("pause");
return 0;
}

 

(作者的解释:)令A[i]表示输入第i个元素,D[i]表示从A[1]到A[i]中以A[i]结尾的最长子序列长度。对于任意的0 <  j <= i-1,如果A(j) < A(i),则A(i)可以接在A(j)后面形成一个以A(i)结尾的新的最长上升子序列。对于所有的 0 <  j <= i-1,我们需要找出其中的最大值。

DP状态转移方程:

D[i] = max{1, D[j] + 1} (j = 1, 2, 3, ..., i-1 且 A[j] < A[i])

解释一下这个方程,i, j在范围内:

如果 A[j] < A[i] ,则D[i] = D[j] + 1

如果 A[j] >= A[i] ,则D[i] = 1

 

其实上面的方法的复杂度都达到了O(n^2)的数量级,有没有更好的解法呢?

有,用栈。

这个解法不是我想的,从网上学来的,这里面与大家分享一下。这个算法的复杂度只有O(nlogn),在有大量数据的情况下,这算法效率极高。。。

(摘录原作者的话)

这个算法其实已经不是DP了,有点像贪心。至于复杂度降低其实是因为这个算法里面用到了二分搜索。本来有N个数要处理是O(n),每次计算要查找N次还是O(n),一共就是O(n^2);现在搜索换成了O(logn)的二分搜索,总的复杂度就变为O(nlogn)了。

这个算法的具体操作如下(by RyanWang):

开一个栈,每次取栈顶元素top和读到的元素temp做比较,如果temp > top 则将temp入栈;如果temp < top则二分查找栈中的比temp大的第1个数,并用temp替换它。 最长序列长度即为栈的大小top。

这也是很好理解的,对于x和y,如果x < y且Stack[y] < Stack[x],用Stack[x]替换Stack[y],此时的最长序列长度没有改变但序列Q的''潜力''增大了。

举例:原序列为1,5,8,3,6,7

栈为1,5,8,此时读到3,用3替换5,得到1,3,8; 再读6,用6替换8,得到1,3,6;再读7,得到最终栈为1,3,6,7。最长递增子序列为长度4。

 

我想,当出现1,5,8,2这种情况时,栈内最后的数是1,2,8不是正确的序列啊?难道错了?

分析一下,我们可以看出,虽然有些时候这样得不到正确的序列了,但最后算出来的个数是没错的,为什么呢?

想想,当temp>top时,总个数直接加1,这肯定没错;但当temp<top时呢? 这时temp肯定只是替换了栈里面的某一个元素,所以大小不变,就是说一个小于栈顶的元素加入时,总个数不变。这两种情况的分析可以看出,如果只求个数的话,这个算法比较高效。但如果要求打印出序列时,就只能用DP了。

用该算法完成POJ2533的具体代码如下:

#include <iostream>
#define SIZE 1001

using namespace std;

int main()
{
int i, j, n, top, temp;
int stack[SIZE];
while(cin >> n)
{
top
= 0;
/* 第一个元素可能为0 */
stack[
0] = -1;
for (i = 0; i < n; i++)
{
cin
>> temp;
/* 比栈顶元素大数就入栈 */
if (temp > stack[top])
{
stack[
++top] = temp;
}
else
{
int low = 1, high = top;
int mid;
/* 二分检索栈中比temp大的第一个数 */
while(low <= high)
{
mid
= (low + high) / 2;
if (temp > stack[mid])
{
low
= mid + 1;
}
else
{
high
= mid - 1;
}
}
/* 用temp替换 */
stack[low]
= temp;
}
}

/* 最长序列数就是栈的大小 */
cout
<< top << endl;
}
return 0;
}

  

 

posted on 2011-08-29 15:18  dartagnan  阅读(12044)  评论(0编辑  收藏  举报