最大连续和问题

最大连续和问题。给出一个长度为 $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$ 的多项式时间算法了。优惠劵 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; 复制链接扫一扫专栏目录挑战程序设计竞赛（第2版） 08-05 世界顶级程序设计高手的经验总结【ACM-ICPC全球总冠军】巫泽俊主译日本ACM-ICPC参赛者人手一册本书对程序设计竞赛中的基础算法和经典问题进行了汇总，分为准备篇、初级篇、中级篇与高级篇4章。作者结合自己丰富的参赛经验，对严格筛选的110 多道各类试题进行了由浅入深、由易及难的细致讲解，并介绍了许多实用技巧。每章后附有习题，供读者练习，巩固所学。本书适合程序设计人员、程序设计竞赛爱好者以及高校计算机专业师生阅读。目录 · · · · · · 译者序前言第1章　蓄势待发——准备篇 1.1 　何谓程序设计竞赛 1.2 　最负盛名的程序设计竞赛 1.2.1 　世界规模的大赛——Google Code Jam（GCJ） 1.2.2 　向高排名看齐！——TopCoder 1.2.3 　历史最悠久的竞赛—— ACM-ICPC 1.2.4 　面向中学生的信息学奥林匹克竞赛——JOI-IOI 1.2.5 　通过网络自动评测——Online Judge（OJ） 1.3 　本书的使用方法 1.3.1 　本书所涉及的内容 1.3.2 　所用的编程语言 1.3.3 　题目描述的处理 1.3.4 　程序结构 1.3.5 　练习题 1.3.6 　读透本书后更上一层楼的练习方法 1.4 　如何提交解答 1.4.1 　POJ的提交方法 1.4.2 　GCJ的提交方法 1.5 　以高效的算法为目标 1.5.1 　什么是复杂度 1.5.2 　关于运行时间 1.6 　轻松热身 1.6.1 　先从简单题开始 1.6.2 　POJ的题目Ants 1.6.3 　难度增加的抽签问题阅读第2章　初出茅庐——初级篇 2.1 　最基础的“穷竭搜索” 2.1.1 　递归函数 2.1.2 　栈 2.1.3 　队列 2.1.4 　深度优先搜索 2.1.5 　宽度优先搜索 2.1.6 　特殊状态的枚举 2.1.7 　剪枝 2.2 　一往直前！贪心法 2.2.1 　硬币问题 2.2.2 　区间问题 2.2.3 　字典序最小问题 2.2.4 　其他例题 2.3 　记录结果再利用的“动态规划” 2.3.1 　记忆化搜索与动态规划 2.3.2 　进一步探讨递推关系 2.3.3 　有关计数问题的DP 2.4 　加工并存储数据的数据结构 2.4.1 　树和二叉树 2.4.2 　优先队列和堆 2.4.3 　二叉搜索树 2.4.4 　并查集 2.5 　它们其实都是“图” 2.5.1 　图是什么 2.5.2 　图的表示 2.5.3 　图的搜索 2.5.4 　最短路问题 2.5.5 　最小生成树 2.5.6 　应用问题 2.6 　数学问题的解题窍门 2.6.1 　辗转相除法 2.6.2 　有关素数的基础算法 2.6.3 　模运算 2.6.4 　快速幂运算 2.7 　一起来挑战GCJ的题目（1） 2.7.1 　Minimum Scalar Product 2.7.2 　Crazy Rows 2.7.3 　Bribe the Prisoners 2.7.4 　Millionaire 阅读第3章　出类拔萃——中级篇 3.1 　不光是查找值！“二分搜索” 3.1.1 　从有序数组中查找某个值 3.1.2 　假定一个解并判断是否可行 3.1.3 　最大化最小值 3.1.4 　最大化平均值 3.2 　常用技巧精选（一） 3.2.1 　尺取法 3.2.2 　反转（开关问题） 3.2.3 　弹性碰撞 3.2.4 　折半枚举（双向搜索） 3.2.5 　坐标离散化 3.3 　活用各种数据结构 3.3.1 　线段树 3.3.2 　Binary Indexed Tree 3.3.3 　分桶法和平方分割 3.4 　熟练掌握动态规划 3.4.1 　状态压缩DP 3.4.2 　矩阵的幂 3.4.3 　利用数据结构高效求解 3.5 　借助水流解决问题的网络流 3.5.1 　最大流 3.5.2 　最小割 3.5.3 　二分图匹配 3.5.4 　一般图匹配 3.5.5 　匹配、边覆盖、独立集和顶点覆盖 3.5.6 　最小费用流 3.5.7 　应用问题 3.6 　与平面和空间打交道的计算几何 3.6.1 　计算几何基础 3.6.2 　极限情况 3.6.3 　平面扫描 3.6.4 　凸包 3.6.5 　数值积分 3.7 　一起来挑战GCJ的题目（2） 3.7.1 　Numbers 3.7.2 　No Cheating 3.7.3 　Stock Charts 3.7.4 　Watering Plants 3.7.5 　Number Sets 3.7.6 　Wi-fi Towers 第4章　登峰造极——高级篇 4.1 　更加复杂的数学问题 4.1.1 　矩阵 4.1.2 　模运算的世界 4.1.3 　计数 4.1.4 　具有对称性的计数 4.2 　找出游戏的必胜策略 4.2.1 　游戏与必胜策略 4.2.2 　Nim 4.2.3 　Grundy数 4.3 　成为图论大师之路 4.3.1 　强连通分量分解 4.3.2 　2-SAT 4.3.3 　LCA 4.4 　常用技巧精选（二） 4.4.1 　栈的运用 4.4.2 　双端队列的运用 4.4.3 　倍增法 4.5 　开动脑筋智慧搜索 4.5.1 　剪枝 4.5.2 　A与IDA* 4.6 　划分、解决、合并：分治法 4.6.1 　数列上的分治法 4.6.2 　树上的分治法 4.6.3 　平面上的分治法 4.7 　华丽地处理字符串 4.7.1 　字符串上的动态规划算法 4.7.2 　字符串匹配 4.7.3 　后缀数组 4.8 　一起来挑战GCJ的题目（3） 4.8.1 　Mine Layer 4.8.2 　Year of More Code Jam 4.8.3 　Football Team 4.8.4 　Endless Knight 4.8.5 　The Year of Code Jam 阅读本书中未涉及的拓展主题书中例题列表参考文献字节码层面理解Switch 没有格子衬衫的程序员 12-16 1013 1. 源码如下，test(int)方法使用switch语法，根据参数a的值返回不同字符串。 public class MySwitchTest { public String test(int a){ switch (a){ case 1: return "a"; case 2: ... 参与评论您还未登录，请先登录后发表或查看评论《计算思维导论》笔记：什么是有限时间内能求解 - 问题的计算复杂性与分类最新发布宋冠巡的博客 12-10 591 《大学计算机—计算思维导论》（战德臣哈尔滨工业大学）《计算思维第14讲 - 什么是有限时间内能求解》什么是有限时间内能求解的问题？什么是难解型问题？ C/C++中的switch语句优化效率的两种方式 C++，存储，模糊测试，Linux 05-24 3126 简介许多编程语言，如C/C++、C#、Java和Pascal，都提供了switch语句，让我们实现选择逻辑。在某些情况下，它是if-then-else的一个很好的替代品，使代码更清晰、更易读。在实践中使用switch时，你可能想知道。 switch块在运行时是如何执行的？对于一长串的条件，它的运行速度是否比if-then-else快？对于n个条件，switch的时间复杂度是多少？ C/C++标准定义了语言元素的规范，但它并没有说如何实现switch语句。只要符合标准，每个厂商都可以自由 c语言圈复杂度switch,干货｜C语言switch\/case圈复杂度优化重构 weixin_42339991的博客 05-19 816 点击上方“中兴开发者社区”，关注我们每天读一篇一线开发者原创好文 ▍作者简介作者陈彬是一名Linux驱动开发工程师，对Linux内核、软件设计和敏捷有较浓厚的兴趣和长期实践经验。自从项目建立起代码质量规范和监控工具后，如何重构高圈复杂度的代码，特别是switch/case的圈复杂度，是同事间比较普遍的一个问题，这正是写本篇文章的起因。希望这篇文章对大家能有所启发。C语言switch/case圈复杂... [个人学习笔记2] 时间复杂度、空间复杂度与switch语句 Pluviophiles的博客 11-27 547 简单讲解时间复杂度、空间复杂度与switch语句时间复杂度一定的算法1s内能处理的问题规模上限 Dart 04-28 5352 复杂度数量级最大规模 O(logN) >>10^20 很大 O(N^1/2) 10^12 10^14 O(N) 10^6 10^7 O(NlogN) 10^5 10^6 O(N^2) 1000 2500 O(N^3) 100 500 O(N^4) 50 50 O(2^N) 20 20 O(3^N) 14 15 O(N!) 9 10 算法设计与分析笔记——算法时间复杂度及五种表示函数的阶的符号等等waiting 09-23 6276 算法时间复杂度评估算法时间复杂度的具体步骤是：（1）找出算法中重复执行次数最多的语句的频度来估算算法的时间复杂度；（2）保留算法的最高次幂，忽略所有低次幂和高次幂的系数；（3）将算法执行次数的数量级放入大Ο记号中。用常数1来取代运行时间中所有加法常数；常见的时间复杂度量有：（1）O(1)：常量阶，运行时间为常量（2）O(logn)：对数阶，如二分搜索算法操作的数量与输入数据的规模... 枚举代替switch并实现O(1)时间复杂度获取名称值王者丶丿风范 06-28 888 枚举代替switch并实现和switch同级别O(1)时间复杂度获取名称值最近边做边玩，看着一个新功能要每个方法写一个switch心生不爽，就给他列巴列巴，看着已经使用了枚举类型，干脆一不做二不休，把枚举搞一搞，说来也巧，枚举搞switch很简单。数组就行，如果有字符串那就加个哈希。自己写呗。我希望通过输入的类型（输入的类型是数字，数字与实际含义通过指定规则对应）直接获取到指定的规则名称。代码如下 /** * 公告类型：1-公告1；2-公告2；3-公告3；4-公告4 * / @AllArgs ACM时间复杂度及算法的选择分析 qq_53775064的博客 12-14 2028 ACM时间复杂度及算法的选择分析一般ACM竞赛C/C++的时间限制是1s，因此可以通过题目数据来推断该题所使用的算法。 IOI国家集训队论文集1999-2019 09-20 项荣璟 -《充分利用问题性质——例析动态规划的"个性化"优化》许智磊 -《浅谈补集转化思想在统计问题中的应用》张宁 -《猜数问题的研究》张云亮 -《论对算法的选择》周源 -《浅析"最小表示法"思想在字符串... 数据结构、算法与应用：C++语言描述（原书第2版）第二部分 12-06 2.3.1 时间复杂度的组成 2.3.2 操作计数 2.3.3 最好、最坏和平均操作计数 2.3.4 步数第3章渐近记法 3.1 引言 3.2 渐近记法 3.2.1 大Ο记法 3.2.2 渐近记法Ω和Θ 3.3 渐近数学（可选） 3.3.1 大O记法 3.3.2 Ω记法... 2008年信息学奥林匹克中国国家国家集训队论文 08-05 2008年信息学奥林匹克中国国家国家集训队论文 [Day1] 1.曹钦翔《数据结构的提炼与压缩》 2.郑暾《平衡规划——浅析一类平衡思想的应用》 ...10.周冬《两极相通——浅析最大—最小定理在信息学竞赛中的应用》 leetcode题库-algorithm:acwing,leetcode,kickstart,算法模板,PAT等等 06-29 算法竞赛进阶指南我的算法模板 TypeScript 算法模板 —— 用于TS/JS 的算法模板库我的对拍程序 Google KickStart LeetCode 伪代码其他的都是之前刷PAT 时候的题目关于算法复杂度在竞赛中，一般算机一秒能运行5 ... 字符串匹配——Sunday算法热门推荐 Switch的博客 07-08 3万+ 字符串匹配——Sunday算法基本思想及举例Sunday算法由Daniel M.Sunday在1990年提出，它的思想跟BM算法很相似：1只不过Sunday算法是从前往后匹配，在匹配失败时关注的是主串中参加匹配的最末位字符的下一位字符。如果该字符没有在模式串中出现则直接跳过，即移动位数 = 模式串长度 + 1；否则，其移动位数 = 模式串长度 - 该字符最右出现的位置(以0开始) = 模式串中该动态规划——基本思想 Switch的博客 07-14 1万+ 动态规划——基本思想动态规划的特点把原始问题划分为一系列子问题求解每个子问题仅一次，并将其结果保存在一个表中，以后用到时到时直接存取，不重复计算，节省计算时间自底向上地计算使用范围一类优化问题：可分为多个相关子问题，子问题的解被重复使用使用动态规划的条件优化子结构当一个问题的优化解包含了子问题的优化解时，这个问题具有优化子结构。缩小子问题集合，只需那些优化问题中包含的子问题，降低分治算法主定理 Switch的博客 05-29 7891 分治算法主定理分治算法通常遵守一种通用模式：即：在解决规模为nn的问题时，总是先递归地求解aa个规模为nb\frac{n}{b}的子问题，然后在O(nd)O(n^d)时间内将子问题的解合并起来，其中a,b,d>0a,b,d > 0是一些特定的整数。分治算法的运行时间可以通过公式：T(n)=aT(⌈nb⌉)+O(nd)T(n) = aT(\lceil \frac{n}{b} \rceil) + O(n 字符串匹配——BMH算法 Switch的博客 07-07 7882 字符串匹配——BMH算法给定主串T和模式串P，返回P在T中首次出现的位置，如果P不存在于T中，返回-1。这样的问题就是字符串匹配问题，这里给出BMH算法的思想。设主串T的长度为n,模式串P的长度为m。BMH(Boyer-Moore-Horspool)算法是BM(Boyer-Moore)算法的一种优化，根据《一种基于BMH算法的模式匹配算法》的分析，BMH算法要优于BM算法，BM算法的思想可以参考字符贪心法——基本思想 Switch的博客 06-03 7703 贪心法——基本思想贪心法，顾名思义表示总是选择当前最优的，以期望达到整体最优。贪心法一般用于求解最优化问题。采用贪心法求最优化问题的算法，一般都包含一系列步骤，每一步都有一组选择，每次都选择当前最优的选择，希望通过局部最优的选择达到全局最优的选择。贪心法不一定总能产生最优解，可能产生近似解甚至完全不正确的答案，故想使用贪心法，最好是能够能够符合贪心法产生优化解的条件。贪心法产生优化解的条件算法中的时间复杂度和空间复杂度 09-21 在计算机科学中，算法的时间复杂度和空间复杂度是衡量算法效率的两个重要指标。时间复杂度指的是算法执行所需的时间量，通常用大 O 记法表示。例如，如果一个算法的时间复杂度*为 O(n)，那么它的执行时间随着输入... “相关推荐”对你有帮助么？非常没帮助没帮助一般有帮助非常有帮助提交 Switchvov CSDN认证博客专家 CSDN认证企业博客码龄13年暂无认证 453 原创 6578 周排名 893 总排名 206万+ 访问等级 1万+ 积分 9489 粉丝 875 获赞 290 评论 2610 收藏私信关注热门文章数据库设计--实体关系图（ERD） 124497 数据库设计--数据流图（DFD） 59139 Struts2标签库常用标签 49048 字符串匹配——Sunday算法 35994 分治法——棋盘覆盖问题 35063 分类专栏 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;
复制链接

扫一扫