最大连续和问题

最大连续和问题。给出一个长度为 $n$ 的序列 $A1, A2,…, An$ ，求最大连续和。换句话说，要求找到 $1≤i≤j≤n$ ，使得 $A_i+A_{i+1}+...+A_j$ 尽量大。

时间复杂度为 $n^3$ 的算法

LL maxConSumN3(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        for(LL j = i; j < n; j++) {
            LL sum = 0;
            for(LL k = i; k <= j; k++) {
                sum += a[k];
                tot++;
            }
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

时间复杂度为 $n^2$ 的算法

LL maxConSumN2(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        LL sum = 0;
        for(LL j = i; j < n; j++) {
            sum += a[j];
            tot++;
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

时间复杂度为 $nlog_2n$ 的算法

// 采用分治法
// 对半划分
// 递归求解左半边和右半边的最大连续和
// 递归边界为left=right
// 求解左右连接部分的最大连续和
// 合并子问题：取三者最大值
LL division(LL *a, LL lef, LL righ) {
    // 递归边界
    if(lef == righ) {
        return a[lef];
    }
    LL center = lef + (righ - lef) / 2;
    // 左半边最大连续和

    LL maxLeftSum = division(a, lef, center);
    // 右半边最大连续和
    LL maxRightSum = division(a, center + 1, righ);
    // 左连接部分最大和
    LL maxLeftConSum = -INF;
    LL leftConSum = 0;
    for(LL i = center; i >= lef; i--) {
        leftConSum += a[i];
        tot++;
        if(leftConSum > maxLeftConSum) {
            maxLeftConSum = leftConSum;
        }
    }
    // 右连接部分最大和
    LL maxRightConSum = -INF;
    LL rightConSum = 0;
    for(LL i = center + 1; i <= righ; i++) {
        rightConSum += a[i];
        tot++;
        if(rightConSum > maxRightConSum) {
            maxRightConSum = rightConSum;
        }
    }
    return max(max(maxLeftSum, maxRightSum), maxLeftConSum + maxRightConSum);
}

LL maxConSumNLogN(LL *a, LL n) {
    return division(a, 0, n - 1);
}

时间复杂度为 $n$ 的算法

LL maxConSumN(LL *a, LL n) {
    conSum = -INF;
    LL sum = 0;
    tot = 0;
    for(int i = 0; i < n; i++) {
        sum += a[i];
        tot++;
        if(sum < 0) {
            sum = 0;
        }
        if(sum > conSum) {
            conSum = sum;
        }
    }
    return conSum;
}

测试主程序

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;
const LL INF = 100000000;

// 总执行次数
LL tot;
// 最大连续和
LL conSum;

// 求最大连续和问题
// n^3的算法
LL maxConSumN3(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        for(LL j = i; j < n; j++) {
            LL sum = 0;
            for(LL k = i; k <= j; k++) {
                sum += a[k];
                tot++;
            }
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

// n^2的算法
LL maxConSumN2(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        LL sum = 0;
        for(LL j = i; j < n; j++) {
            sum += a[j];
            tot++;
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

// nlogn的算法
// 采用分治法
// 对半划分
// 递归求解左半边和右半边的最大连续和
// 递归边界为left=right
// 求解左右连接部分的最大连续和
// 合并子问题：取三者最大值
LL division(LL *a, LL lef, LL righ) {
    // 递归边界
    if(lef == righ) {
        return a[lef];
    }
    LL center = lef + (righ - lef) / 2;
    // 左半边最大连续和

    LL maxLeftSum = division(a, lef, center);
    // 右半边最大连续和
    LL maxRightSum = division(a, center + 1, righ);
    // 左连接部分最大和
    LL maxLeftConSum = -INF;
    LL leftConSum = 0;
    for(LL i = center; i >= lef; i--) {
        leftConSum += a[i];
        tot++;
        if(leftConSum > maxLeftConSum) {
            maxLeftConSum = leftConSum;
        }
    }
    // 右连接部分最大和
    LL maxRightConSum = -INF;
    LL rightConSum = 0;
    for(LL i = center + 1; i <= righ; i++) {
        rightConSum += a[i];
        tot++;
        if(rightConSum > maxRightConSum) {
            maxRightConSum = rightConSum;
        }
    }
    return max(max(maxLeftSum, maxRightSum), maxLeftConSum + maxRightConSum);
}

LL maxConSumNLogN(LL *a, LL n) {
    return division(a, 0, n - 1);
}

// n的算法
LL maxConSumN(LL *a, LL n) {
    conSum = -INF;
    LL sum = 0;
    tot = 0;
    for(int i = 0; i < n; i++) {
        sum += a[i];
        tot++;
        if(sum < 0) {
            sum = 0;
        }
        if(sum > conSum) {
            conSum = sum;
        }
    }
    return conSum;
}

int main() {
    LL a[] = {-2, 3, 4, 5, -6, 7, -1, 2, 6};
    cout << "时间复杂度为N^3的算法:" << maxConSumN3(a, 9);
    cout << "\t 计算次数为:" << tot << endl;

    cout << "时间复杂度为N^2的算法:" << maxConSumN2(a, 9);
    cout << "\t 计算次数为:" << tot << endl;

    tot = 0;
    cout << "时间复杂度为NLogN的算法:" << maxConSumNLogN(a, 9);
    cout << "\t 计算次数为:" << tot << endl;

    cout << "时间复杂度为N的算法:" << maxConSumN(a, 9);
    cout << "\t\t 计算次数为:" << tot << endl;

    return 0;
}

输出结果为

时间复杂度为N^3的算法:20         计算次数为:165
时间复杂度为N^2的算法:20         计算次数为:45
时间复杂度为NLogN的算法:20       计算次数为:29
时间复杂度为N的算法:20           计算次数为:9

Process returned 0 (0x0)   execution time : 0.196 s
Press any key to continue.

算法竞赛中的时间复杂度选择

假设机器速度是每秒 $10^8$ 次基本运算，运算量为 $n^3、n^2、nlog_2n、n、2^n$ （如子集枚举）和 $n!$ （如排列枚举）的算法，在1秒之内能解决最大问题规模 $n$ ，如表所示：


运算量	$n!$ $2^n$ $n^3$ $n^2$ $nlog_2n$ $n$
最大规模	$11$ $26$ $464$ $10000$ $4.510^6$ $100000000$ 速度扩大两倍以后 $11$ $27$ $584$ $14142$ $8.610^6$ $200000000$ 运算量随着规模的变化表还给出了机器速度扩大两倍后，算法所能解决规模的对比。可以看出， $n!$ 和 $2^n$ 不仅能解决的问题规模非常小，而且增长缓慢；最快的 $nlog2_n$ 和 $n$ 算法不仅解决问题的规模大，而且增长快。渐进时间复杂为多项式的算法称为多项式时间算法（polymonial-time algorithm），也称有效算法；而 $n!$ 或者 $2^n$ 这样的低效的算法称为指数时间算法（exponentialtime algorithm）。不过需要注意的是，上界分析的结果在趋势上能反映算法的效率，但有两个不精确性：一是公式本身的不精确性。例如，“非主流”基本操作的影响、隐藏在大O记号后的低次项和最高项系数；二是对程序实现细节与计算机硬件的依赖性，例如，对复杂表达式的优化计算、把内存访问方式设计得更加“cache友好”等。在不少情况下，算法实际能解决的问题规模与表所示有着较大差异。尽管如此，表还是有一定借鉴意义的。考虑到目前主流机器的执行速度，多数算法竞赛题目所选取的数据规模基本符合此表。例如，一个指明 $n≤8$ 的题目，可能 $n!$ 的算法已经足够， $n≤20$ 的题目需要用到 $2^n$ 的算法，而 $n≤300$ 的题目可能必须用至少 $n^3$ 的多项式时间算法了。确定要放弃本次机会？福利倒计时 : : 立减 ¥ 普通VIP年卡可用立即使用 Switchvov 关注关注 1 点赞踩 6 收藏觉得还不错? 一键收藏 0 评论算法竞赛中的时间复杂度选择——以最大连续和问题为例最大连续和问题最大连续和问题。给出一个长度为nn的序列 A1,A2,…,AnA1, A2,…, An，求最大连续和。换句话说，要求找到1≤i≤j≤n1≤i≤j≤n，使得Ai+Ai+1+...+AjA_i+A_{i+1}+...+A_j尽量大。时间复杂度为n3n^3的算法LL maxConSumN3(LL a, LL n) { tot = 0; conSum = -INF; 复制链接扫一扫专栏目录对求最大连续子序列和问题四种算法的分析 m0_73852401的博客 03-22 1254 对求最大连续子序列和问题四种算法的分析（暴力枚举、优化枚举、动态规划、分治递归）计算机算法分析与设计最大连续子序列 11-08 题目是标准的ACM竞赛题，word文档里包含求最大连续子序列的题目和完整的实验代码，并在VC6.0上运行通过！！！参与评论您还未登录，请先登录后发表或查看评论最大连续和问题 altoer的博客 03-06 672 此处介绍四种方法，复杂度in descending order 一、O(n^3) 普通做法；即在数组中，遍历起始和终止位置，然后从起始到终止位置累加求和，求得的sum与最大值比较，如果比最大值大，就赋值； int best = 0;//ans for(int i = 1; i <= n; i++) for(int j = i; j <= n; j++) { int sum =... 最大连续和 MyLinChi的博客 12-17 849 问题描述: 给出一个长度为n的序列,求出最大连续和。就是找出1尽量大。方法一：直接枚举i，j，找出连续和最大的i，j。 #include #include using namespace std; int A[1000],n; int main() { cin >> n; for (int i = 1; i > A[i]; int sum = A[1]; for (int i = 经典算法问题 - 最大连续子数列和 weixin_30768175的博客 08-14 257 维基百科：在计算机科学中，最大子数列问题的目标是在数列的一维方向找到一个连续的子数列，使该子数列的和最大。例如，对一个数列 −2, 1, −3, 4, −1, 2, 1, −5, 4，其连续子数列中和最大的是 4, −1, 2, 1, 其和为6。时间复杂度：O（N^3）最粗鲁的做法就是直接三重循环，起点i，终点j，k是从i到j 代码如下： #include <bit... 刘汝佳《算法竞赛入门经典——训练指南》源代码 01-26 通过这些代码，你可以学习到如何在实际问题中选择合适的排序算法，并了解它们的时间复杂度和空间复杂度。 2. 搜索算法：深度优先搜索（DFS）和广度优先搜索（BFS）是解决问题的重要工具。源代码可能会展示如何... 算法竞赛入门经典——算法实现.docx 09-13 算法竞赛的分类和方法可以按照以下几种方式进行：根据算法复杂度、思考时间、运行效率、问题类型等。掌握多种算法是十分重要的，这不仅可以帮助参赛者更好地解决不同类型的问题，还可以提高他们的解决问题的能力和... 算法设计与分析-以大学生程序竞赛为例(PPT) 09-26 通过学习清华大学出版社的这本《算法设计与分析——以大学生程序设计竞赛为例》的PPT，学生们不仅可以系统地掌握算法设计的基本原理，还能通过实例深入理解各种算法的应用，提高他们在实际问题中的解决能力。... 算法（c++）——循环比赛日程安排问题.rar 12-04 8. 性能优化：根据实际需求，可以考虑优化算法以减少时间复杂度，例如通过更高效的匹配策略或提前判断无效的配对。通过上述步骤，我们可以使用C++成功解决循环比赛日程安排问题。这个过程不仅可以帮助我们理解... ACM数论经典初级进阶1基础题目详解10道.docx ) 03-19 ACM数论经典初级进阶1基础题目详解10道.docx ) 算法和数据结构——左程云.zip 最新发布 06-17 左程云可能会介绍如何设计算法，如贪心算法、动态规划、回溯法等，并教授如何分析算法的时间复杂度和空间复杂度，这是评估算法效率的关键指标。此外，还可能涉及如何使用递归和迭代等编程技巧来实现算法。四、实战... 算法学习资料——算法.zip 07-24 - 算法分析：评估算法的效率主要通过时间复杂度和空间复杂度，这有助于我们选择最优解。 2. 常见算法类型： - 排序算法：如冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等，每种排序算法都有其... 信息学竞赛中关于部分搜索算法的问题 12-05 ### 信息学竞赛中关于部分搜索算法的问题 #### 深度优先搜索的非常规搜索：部分搜索+高效搜索！一、引言* 在信息学竞赛中，尤其是在解决复杂问题时，传统的搜索方法往往难以满足高效求解的需求。面对这类问题... NOI导刊-枚举与搜索_NOI_枚举_搜索_算法竞赛_ 10-02 【标题】"NOI导刊-枚举与搜索"是一份专为算法竞赛设计的教程，由长沙市...通过学习，参赛者将更好地理解如何在实际问题中灵活运用这两种策略，提高解决问题的能力，为在NOI等算法竞赛中取得优异成绩打下坚实的基础。用函数指针数组简化switch-case跳转二维事件复杂度 findaway123的专栏 06-04 2430 在多任务程序中，多个任务之间采用消息队列来传递信息和交互，如果在任务循环中采用如下的跳转来操作，那么就会增加计算时间： while(1) { state = get_message(); switch(state) { case RUN: do_something(); [个人学习笔记2] 时间复杂度、空间复杂度与switch语句 Pluviophiles的博客 11-27 611 简单讲解时间复杂度、空间复杂度与switch语句算法刷题必会知识：由数据范围反推算法时间复杂度阿正的梦工坊 01-05 422 记录知识，形成体系 Switchvov CSDN认证博客专家 CSDN认证企业博客码龄14年暂无认证 453 原创 9149 周排名 1万+ 总排名 208万+ 访问等级 2万+ 积分 9788 粉丝 881 获赞 289 评论 2660 收藏私信关注热门文章数据库设计--实体关系图（ERD） 129387 数据库设计--数据流图（DFD） 59724 Struts2标签库常用标签 49185 字符串匹配——Sunday算法 36591 分治法——棋盘覆盖问题 35225 分类专栏 Skywalking 13篇开发规范 1篇深入浅出Oracle 17篇 RocketMQ 3篇渐入佳境的Java学习之路 14篇 Hibernate学习笔记 8篇 UML与需求分析学习笔记 12篇 Servlet学习笔记 14篇 XML使用教程 6篇 ACM 151篇 AJAX 3篇 Algorithm 36篇 Big Data 1篇 Conclusion 2篇 Concurrence 8篇 Database 2篇 Data Structure 3篇 Design Pattern 23篇 Dubbo Git 4篇 Hibernate 14篇 HTML 7篇 JavaSE 29篇 JavaEE 3篇 Javascript 18篇 JDBC 6篇 JSON 1篇 JSP 5篇 Linux 14篇 Maven 3篇 MQ 1篇 MyBatis 3篇 MySQL 4篇 Network Oracle 18篇 PHP 8篇 Python 6篇 Reading 4篇 Regular Expression 3篇 Redis 4篇 Servlet 22篇 Shiro 1篇 Skill 3篇 Software Test 3篇 Spring 18篇 SpringBoot 3篇 SpringCloud 1篇 SpringMVC 5篇 Struts1 6篇 Struts2 13篇 UML 13篇 Vue.js 1篇 Web Crawler Web Service 1篇 XML 7篇最新评论字符串匹配——Sunday算法氵文大师: 很棒，很棒好清楚啊！！！字符串匹配——BMH算法皮卡丘丘桑: 偏移表的作用是什么怎样用Java 8优雅的开发业务渡劫狱: 狗叫分治法——棋盘覆盖问题影月丶暮风: 在n超过10之后，地图会大范围爆0，我和你的程序都有这个问题数据库设计--数据流图（DFD）不学精通不改名: 我想问一下博主顶层分解以后是0层流图还是1层流图最新文章 Java Maven项目推送到 Maven 中央仓库 2021总结、2022展望 IDEA远程部署调试Java应用程序 2024年1篇 2021年15篇 2020年3篇 2019年3篇 2018年2篇 2017年67篇 2016年279篇 2015年87篇目录目录分类专栏 Skywalking 13篇开发规范 1篇深入浅出Oracle 17篇 RocketMQ 3篇渐入佳境的Java学习之路 14篇 Hibernate学习笔记 8篇 UML与需求分析学习笔记 12篇 Servlet学习笔记 14篇 XML使用教程 6篇 ACM 151篇 AJAX 3篇 Algorithm 36篇 Big Data 1篇 Conclusion 2篇 Concurrence 8篇 Database 2篇 Data Structure 3篇 Design Pattern 23篇 Dubbo Git 4篇 Hibernate 14篇 HTML 7篇 JavaSE 29篇 JavaEE 3篇 Javascript 18篇 JDBC 6篇 JSON 1篇 JSP 5篇 Linux 14篇 Maven 3篇 MQ 1篇 MyBatis 3篇 MySQL 4篇 Network Oracle 18篇 PHP 8篇 Python 6篇 Reading 4篇 Regular Expression 3篇 Redis 4篇 Servlet 22篇 Shiro 1篇 Skill 3篇 Software Test 3篇 Spring 18篇 SpringBoot 3篇 SpringCloud 1篇 SpringMVC 5篇 Struts1 6篇 Struts2 13篇 UML 13篇 Vue.js 1篇 Web Crawler Web Service 1篇 XML 7篇目录评论被折叠的条评论为什么被折叠? 到【灌水乐园】发言查看更多评论添加红包祝福语请填写红包祝福语或标题红包数量个红包个数最小为10个红包总金额元红包金额最低5元余额支付当前余额3.43元前往充值 > 需支付：10.00元成就一亿技术人! 领取后你会自动成为博主和红包主的粉丝规则 hope_wisdom 发出的红包实付元使用余额支付点击重新获取扫码支付钱包余额 0 抵扣说明： 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。余额充值

运算量

n! $n!$

2n $2^n$

n3 $n^3$

n2 $n^2$

nlog2n $nlog_2n$

n $n$

最大规模

11 $11$

26 $26$

464 $464$

10000 $10000$

4.5∗106 $4.5*10^6$

100000000 $100000000$ 速度扩大两倍以后

11 $11$

27 $27$

584 $584$

14142 $14142$

8.6∗106 $8.6*10^6$

200000000 $200000000$

运算量随着规模的变化

表还给出了机器速度扩大两倍后，算法所能解决规模的对比。可以看出， $n!$ 和 $2^n$ 不仅能解决的问题规模非常小，而且增长缓慢；最快的 $nlog2_n$ 和 $n$ 算法不仅解决问题的规模大，而且增长快。渐进时间复杂为多项式的算法称为多项式时间算法（polymonial-time algorithm），也称有效算法；而 $n!$ 或者 $2^n$ 这样的低效的算法称为指数时间算法（exponentialtime algorithm）。

不过需要注意的是，上界分析的结果在趋势上能反映算法的效率，但有两个不精确性：一是公式本身的不精确性。例如，“非主流”基本操作的影响、隐藏在大O记号后的低次项和最高项系数；二是对程序实现细节与计算机硬件的依赖性，例如，对复杂表达式的优化计算、把内存访问方式设计得更加“cache友好”等。在不少情况下，算法实际能解决的问题规模与表所示有着较大差异。

尽管如此，表还是有一定借鉴意义的。考虑到目前主流机器的执行速度，多数算法竞赛题目所选取的数据规模基本符合此表。例如，一个指明 $n≤8$ 的题目，可能 $n!$ 的算法已经足够， $n≤20$ 的题目需要用到 $2^n$ 的算法，而 $n≤300$ 的题目可能必须用至少 $n^3$ 的多项式时间算法了。

Switchvov

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
算法竞赛中的时间复杂度选择——以最大连续和问题为例

最大连续和问题最大连续和问题。给出一个长度为nn的序列 A1,A2,…,AnA1, A2,…, An，求最大连续和。换句话说，要求找到1≤i≤j≤n1≤i≤j≤n，使得Ai+Ai+1+...+AjA_i+A_{i+1}+...+A_j尽量大。时间复杂度为n3n^3的算法LL maxConSumN3(LL *a, LL n) { tot = 0; conSum = -INF;
复制链接

扫一扫