问题描述：

输入一组整数，求出这组数字子序列和中最大值。也就是只要求出最大子序列的和，不必求出最大的那个序列。例如：

序列：-2 11 -4 13 -5 -2，则最大子序列和为20。

序列：-6 2 4 -7 5 3 2 -1 6 -9 10 -2，则最大子序列和为16。

算法一：

//穷举法，复杂度O(n^3)

long maxSubSum1(const vector<int>& a)

{

long maxSum = 0;

for (int i = 0; i < a.size(); i++)

{

for (int j = i; j < a.size(); j++)

{

long thisSum = 0;

for (int k = i; k <= j; k++)

{

thisSum += a[k];

}

if (thisSum > maxSum)

maxSum = thisSum;

}

}

return maxSum;

}

这是一个O(N^3) 的算法，算法本身很容易理解，而且很直观的感觉做了很多无用操作。例如：i = 0, j = 3时，会计算a[0] + a[1] +…+ a[3]；而当i = 0, j = 4时候又会计算a[0] + a[1] +…a[4]。

算法二：

通过撤出一个for循环来避免三次时间。

//也是穷举法，不过减去了上面的一些不必要操作O(n^2)

long maxSubSum2(const vector<int>& a)

{

long maxSum = 0;

for (int i = 0; i < a.size(); i++)

{

long thisSum = 0;

for (int j = i; j < a.size(); j++)

{

thisSum += a[j];

if (thisSum > maxSum)

maxSum = thisSum;

}

}

return maxSum;

}

这是一个非常直观的穷举法（比上面的分析还有简单些），而且没有多余重复的操作，复杂度为O(N^2) 。其中，thisSum表示a[i] + a[i+1] + … + a[j-1]。

算法三：

对这个问题，有一个相对复杂的O(NlogN)的解法，就是使用递归。如果要是求出序列的位置的话，这将是最好的算法了（因为我们后面还会有个O(N)的算法，但是不能求出最大子序列的位置）。该方法我们采用“分治策略”（divide-and-conquer）。

在 我们例子中，最大子序列可能在三个地方出现，或者在左半部，或者在右半部，或者跨越输入数据的中部而占据左右两部分。前两种情况递归求解，第三种情况的最 大和可以通过求出前半部分最大和（包含前半部分最后一个元素）以及后半部分最大和（包含后半部分的第一个元素）相加而得到。

//递归法，复杂度是O(nlogn)

long maxSumRec(const vector<int>& a, int left, int right)

{

if (left == right)

{

if (a[left] > 0)

return a[left];

else

return 0;

}

int center = (left + right) / 2;

long maxLeftSum = maxSumRec(a, left, center);

long maxRightSum = maxSumRec(a, center+1, right);

//求出以左边对后一个数字结尾的序列最大值

long maxLeftBorderSum = 0, leftBorderSum = 0;

for (int i = center; i >= left; i--)

{

leftBorderSum += a[i];

if (leftBorderSum > maxLeftBorderSum)

maxLeftBorderSum = leftBorderSum;

}

//求出以右边对后一个数字结尾的序列最大值

long maxRightBorderSum = 0, rightBorderSum = 0;

for (int j = center+1; j <= right; j++)

{

rightBorderSum += a[j];

if (rightBorderSum > maxRightBorderSum)

maxRightBorderSum = rightBorderSum;

}

return max3(maxLeftSum, maxRightSum,

maxLeftBorderSum + maxRightBorderSum);

}

long maxSubSum3(const vector<int>& a)

{

return maxSumRec(a, 0, a.size()-1);

}

另外max3(long,long,long)表示求三个long中的最大值：

//求出三个long中的最大值

long max3(long a, long b, long c)

{

if (a < b)

{

a = b;

}

if (a > c)

return a;

else

return c;

}

对这个算法进行分析：

T(1) = 1 

T(N) = 2T(N/2) + O(N) 

最后得出算法的复杂度为：O(NlogN) 。

算法四：

下面介绍一个线性的算法，这个算法是许多聪明算法的典型：运行时间是明显的，但是正确性则很不明显（不容易理解）。

//线性的算法O(N)

long maxSubSum4(const vector<int>& a)

{

long maxSum = 0, thisSum = 0;

for (int j = 0; j < a.size(); j++)

{

thisSum += a[j];

if (thisSum > maxSum)

maxSum = thisSum;

else if (thisSum < 0)

thisSum = 0;

}

return maxSum;

}

很容易理解时间界O(N) 是正确的，但是要是弄明白为什么正确就比较费力了。其实这个是算法二的一个改进。分析的时候也是i代表当前序列的起点，j代表当前序列的终点。如果我们不需要知道最佳子序列的位置，那么i就可以优化掉。

    重点的一个思想是：如果a[i]是负数那么它不可能代表最有序列的起点，因为任何包含a[i]的作为起点的子序列都可以通过用a[i+1]作为起点来改进。类似的有，任何的负的子序列不可能是最优子序列的前缀。例如说，循环中我们检测到从a[i]到a[j]的子序列是负数，那么我们就可以推进i。关键的结论是我们不仅可以把i推进到i+1，而且我们实际可以把它一直推进到j+1。

举例来说，令p是i+1到j之间的任何一个下标，由于前面假设了a[i]+…+a[j]是负数，则开始于下标p的任意子序列都不会大于在下标i并且包含从a[i]到a[p-1]的子序列对应的子序列（j是使得从下标i开始成为负数的第一个下标）。因此，把i推进到j+1是安全的，不会错过最优解。注意的是：虽然，如果有以a[j]结尾的某序列和是负数就表明了这个序列中的任何一个数不可能是与a[j]后面的数形成的最大子序列的开头，但是并不表明a[j]前面的某个序列就不是最大序列，也就是说不能确定最大子序列在a[j]前还是a[j]后，即最大子序列位置不能求出。但是能确保maxSum的值是当前最大的子序列和。这个算法还有一个有点就是，它只对数据进行一次扫描，一旦a[j]被读入处理就不需要再记忆。它是一个联机算法。

联机算法：在任意时刻算法都能够对它已读入的数据给出当前数据的解。 

常量空间线性时间的联机算法几乎是完美的算法。

附录：

程序测试：

先通过文件读写函数产生一组随机数并且读入到一个vector<int>中：

//COUNT和MAX_NUM分别表示随机数个数和最大值

const long COUNT = 1000;

const int MAX_NUM = 200;

//读文件

bool readFile(vector<int>& input, string fileName)

{

ifstream infile(fileName.c_str());

if (!infile)

return false;

int s;

while(infile>>s)

{

input.push_back(s);

}

return true;

}

//写大量随机测试数据

bool writeTestData(string fileName)

{

ofstream outfile(fileName.c_str());

if (!outfile)

return false;

srand((unsigned)time(NULL));

for (int i = 0; i < COUNT; i++)

{

if (rand() % 2 == 0)

outfile << rand() % MAX_NUM << '\n';

else

outfile << ~(rand() % MAX_NUM) << '\n';

}

return true;

}

测试可得：

当COUNT = 1000的时候maxSubSum1()要等10s，后三个很快。

当COUNT = 10000的时候maxSubSum2()要等8s，后两个很快。

当COUNT = 1000000的时候maxSubSum3()要等10s，maxSubSum4()要等4s。

其实当COUNT = 1000000这个时候但是作文件读写就要很耗时了，光是in.txt就达到了4.7MB了。

而COUNT = 10000000的时候光是文件读写就要半分钟，in.txt达到了47.2MB，这时候再做maxSubSum3()和maxSubSum4()的比较，maxSubSum4()需要56s，而maxSubSum3()这时候需要85s（包括了读文件的时间）。可见数据量比较大的情况下O(NlogN)的递归算法也是可行的，并不比O(N)低很多。尤其在要求出最大子序列位置的情况下，分治递归算法体现了强大的威力。

程序源码：

#include <iostream>

#include <string>

#include <vector>

#include <fstream>

#include <cstdlib>

#include <ctime>

using namespace std;

//COUNT和MAX_NUM分别表示随机数个数和最大值

const long COUNT = 10000;

const int MAX_NUM = 200;

//读文件

bool readFile(vector<int>& input, string fileName)

{

ifstream infile(fileName.c_str());

if (!infile)

return false;

int s;

while(infile>>s)

{

input.push_back(s);

}

return true;

}

//写大量随机测试数据

bool writeTestData(string fileName)

{

ofstream outfile(fileName.c_str());

if (!outfile)

return false;

srand((unsigned)time(NULL));

for (int i = 0; i < COUNT; i++)

{

if (rand() % 2 == 0)

outfile << rand() % MAX_NUM << '\n';

else

outfile << ~(rand() % MAX_NUM) << '\n';

}

return true;

}

//穷举法

long maxSubSum1(const vector<int>& a)

{

long maxSum = 0;

for (int i = 0; i < a.size(); i++)

{

for (int j = i; j < a.size(); j++)

{

long thisSum = 0;

for (int k = i; k <= j; k++)

{

thisSum += a[k];

}

if (thisSum > maxSum)

maxSum = thisSum;

}

}

return maxSum;

}

//也是穷举法，不过减去了上面的一些不必要操作O(n^2)

long maxSubSum2(const vector<int>& a)

{

long maxSum = 0;

for (int i = 0; i < a.size(); i++)

{

long thisSum = 0;

for (int j = i; j < a.size(); j++)

{

thisSum += a[j];

if (thisSum > maxSum)

maxSum = thisSum;

}

}

return maxSum;

}

//递归法，复杂度是O(nlogn)

long max3(long a, long b, long c)

{

if (a < b)

{

a = b;

}

if (a > c)

return a;

else

return c;

}

long maxSumRec(const vector<int>& a, int left, int right)

{

if (left == right)

{

if (a[left] > 0)

return a[left];

else

return 0;

}

int center = (left + right) / 2;

long maxLeftSum = maxSumRec(a, left, center);

long maxRightSum = maxSumRec(a, center+1, right);

//求出以左边对后一个数字结尾的序列最大值

long maxLeftBorderSum = 0, leftBorderSum = 0;

for (int i = center; i >= left; i--)

{

leftBorderSum += a[i];

if (leftBorderSum > maxLeftBorderSum)

maxLeftBorderSum = leftBorderSum;

}

//求出以右边对后一个数字结尾的序列最大值

long maxRightBorderSum = 0, rightBorderSum = 0;

for (int j = center+1; j <= right; j++)

{

rightBorderSum += a[j];

if (rightBorderSum > maxRightBorderSum)

maxRightBorderSum = rightBorderSum;

}

return max3(maxLeftSum, maxRightSum,

maxLeftBorderSum + maxRightBorderSum);

}

long maxSubSum3(const vector<int>& a)

{

return maxSumRec(a, 0, a.size()-1);

}

//线性的算法O(N)

long maxSubSum4(const vector<int>& a)

{

long maxSum = 0, thisSum = 0;

for (int j = 0; j < a.size(); j++)

{

thisSum += a[j];

if (thisSum > maxSum)

maxSum = thisSum;

else if (thisSum < 0)

thisSum = 0;

}

return maxSum;

}

int main ()

{

vector<int> input;

/**

if (!writeTestData("in.txt"))

{

cout << "写文件错误" << endl;

}

*/

if (readFile(input, "in.txt"))

{

//cout << maxSubSum1(input) << endl;

//cout << maxSubSum2(input) << endl;

cout << maxSubSum3(input) << endl;

cout << maxSubSum4(input) << endl;

}

return 0;

}

转载于:https://www.cnblogs.com/end/archive/2012/02/04/2337793.html

（zz）最大子序列和问题相关推荐

  1. 最大连续子序列(dp)

    Problem Description 给定K个整数的序列{ N1, N2, ..., NK },其任意连续子序列可表示为{ Ni, Ni+1, ...,  Nj },其中 1 <= i < ...

  2. 简(kun)单(nan)到让我开(jue)心(wang)的后缀自动机全家桶（普通后缀、广义后缀、子序列）...

    目录 参考文献 后缀自动机是什么神仙玩意? 例题 right集合.等价类以及Parent树 定义 等价类性质 Trie?DAG? 自动机?自动鸡? 自动机的基本性质 一定存在后缀自动机吗? 后缀自动机 ...

  3. 最长公共子序列LCS（动态规划）—详解

    一.基本概念 1. 子序列(subsequence): 一个特定序列的子序列就是将给定序列中零个或多个元素去掉后得到的结果(不改变元素间相对次序).例如序列<A,B,C,B,D,A,B>& ...

  4. 用动态规划解决最长公共子序列问题 C语言,动态规划之最长公共子序列问题 C++实现...

    这个问题经常运用在判断两种生物的相似度--DNA比对上.对比俩串的方式有很多种,例如如果一个串是另一个的字串,那么可以说两个串是相似的:如果将一个串转换为另一个串的操作很少,那么也可以说这两个串是相似 ...

  5. LeetCode简单题之最长和谐子序列

    题目 和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 . 现在,给你一个整数数组 nums ,请你在所有可能的子序列中找到最长的和谐子序列的长度. 数组的子序列是一个由数组派生出来的 ...

  6. 最长公共子序列（LCS）问题 Longest Common Subsequence 与最长公告字串 longest common substr...

    问题描述:字符序列的子序列是指从给定字符序列中随意地(不一定连续)去掉若干个字符(可能一个也不去掉)后所形成的字符序列.令给定的字符序列X="x0,x1,-,xm-1",序列Y=& ...

  7. 最长连续子序列nlogn算法

    最长上升子序列(LIS)长度的O(nlogn)算法 标签: 算法search优化存储 2012-04-18 19:38 14031人阅读 评论(5) 收藏 举报  分类: 资料学习(15)  解题报告 ...

  8. 经典dp最长递增子序列

    经典dp最大递增子序列,  看了好长时间,看了好多版本.最终因为这个看懂,也觉得这个是最全面的吧,我感觉我好菜啊. http://wenku.baidu.com/view/bed07b15552707 ...

  9. leetcode-300 最长上升子序列

    题目描述: 给定一个无序的整数数组,找到其中最长上升子序列的长度. 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101],它的长度 ...

  10. leetcode-152 乘积最大子序列

    题目描述: 给定一个整数数组 nums ,找出一个序列中乘积最大的连续子序列(该序列至少包含一个数). 示例 1: 输入: [2,3,-2,4] 输出: 6 解释: 子数组 [2,3] 有最大乘积 6 ...

最新文章

  1. oracle补丁怎么配置,如何检查Oracle补丁是否已安装？
  2. 【Scratch】青少年蓝桥杯_每日一题_8.09_列表
  3. Spring Boot中如何干掉if else
  4. 深度学习如何验证自己的想法
  5. C++关系运算符重载
  6. Jerry和您聊聊Chrome开发者工具
  7. 【转】细说.NET中的多线程 (三 使用Task)
  8. app store 服务器维护,AppStore无法连接怎么办？几个小方法教你解决问题
  9. python 暂停程序 等待用户输入_遇上Python程序暂停时，不要慌，教你正确的处理方法...
  10. 《『若水新闻』客户端开发教程》——15代码编写(7)
  11. 机器学习相关基本术语
  12. 别人：OpenCV学习笔记（一）——安装配置、第一个程序(http://blog.csdn.net/yang_xian521/article/details/6894228)...
  13. Oracle 安装 与 卸载 以及 使用 plsqldev
  14. 11.云计算平台（数据科学概论）
  15. 网站漏洞修复之CSRF跨站攻击
  16. jsp实现页面自动跳转
  17. 刷脸支付便利更好推动普惠金融的落地
  18. 使用Senparc.Weixin SDK搭建微信公众号服务程序
  19. linux进程等待wait()实例
  20. 关于SSD写放大问题

热门文章

  1. 分层架构（第一张章）
  2. [转]献给2010年仍然单身的80后
  3. 【转】超现实的经典语录
  4. WHILE (Transact-SQL)
  5. es6笔记 day1---let和const的应用
  6. SWUST OJ(953)
  7. http://jingyan.baidu.com/article/636f38bb3eb78ad6b8461082.html
  8. Android开发中的全屏背景显示方案
  9. 传播路径图调查2013年初
  10. 基于axis2的webservice和android简单的本地数据交互（下）