最大子段和三种算法实现

最新推荐文章于 2024-04-14 08:18:48 发布
最新推荐文章于 2024-04-14 08:18:48 发布
阅读量5.4k 收藏 50
点赞数 5
分类专栏： 算法 文章标签： 算法 数据结构 动态规划 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46274553/article/details/113880756
版权

问题描述

给定由 n 个整数（可能为负整数）组成的序列 a1、a2、……an，求该序列形如在这里插入图片描述
的子段和的最大值。当所有整数均为负整数时定义其最大子段和为 0。依次定义，所求的最优值为

max{
在这里插入图片描述

例如：当(a1,a2,a3,a4,a5,a6)=(-2,11,-4,13,-5,-2)时，最大子段和为在这里插入图片描述
=20。

三种算法求解

1、暴力算法

算法分析：

通过阅读了解问题后，可以初步尝试用最简单的方法解决问题，方便发现问题本质。最大子段和的结果很明显是通过：对数组排列组合得出子段和的个数，然后一一对比得出结果。

求子段和的个数需要两个循环：外循环是循环起点，内循环是循环终点。

求子段和对比结果需要一个循环。

三个for循环的时间复杂度是O（n3），然而在第二个for循环求处子段个数时就可以进行子段和比较了，省去最后一个for循环，使得算法时间复杂度为O(n2)。

算法实现：

算法伪代码：

在这里插入图片描述

2. 分治算法

算法分析：

可以从数组中间分开，结果要么在左边或右边，要么就在中间。结果在左边和右边的情况好办，那在中间的情况该如何分析呢？因为子段是连续的，所以结果只能从中心向两边扩，采用枚举法，左右走到尽头，结果相加就得到中间的最大解。所以该题采用分治算法的难度就可以解决了。

拆分子数组分别求得的最大子段和为sum1,sum2。时间复杂度为2T(N/2),从中心点向两边找最大的和，找到跨越的最大子段和的时间复杂度为O(n), 所以总体的时间复杂度为：T(n)=2T(n/2)+O(n) = O(nlogn)。

算法实现：

算法伪代码：

在这里插入图片描述

3. 动态规划

算法分析：

首先，该问题的解法符合动态规划的思想。

一、子问题重叠：无论问题规模怎么变化，最大子段和的子段都是在数组中。

二、原问题的最优解包含子问题的最优解：通过最简单的方法，我称之为暴力带值。列出小问题规模的结果，通过矩阵a[i]存入数值：

a[i]-211-413-5-2

在分治算法中，需要枚举n个数组，那如果从a[0]开始枚举，得到一段子段和是负数，那还需要用到该子段吗？显然不需要，直接从当前元素重新开始。

假定子段终点为a[j]，那么之前的和必定为正且最大，设置b[i]数组记录a[j]结尾的全部子段的和，所以当b[j]>0时，b[j]=b[j-1]+a[j],否则b[j]=a[j]，由此得到b[j]的动态规划递归式：

b[j]=max{b[j-1]+a[j],a[j]}, 1≤j≤n

b-2117201513
sum0117202020

算法实现：

算法伪代码：

在这里插入图片描述

上述算法显然时间复杂度时O(n)，空间复杂度是O(n)。

算法结果

输出结果（取一次）

在这里插入图片描述

复杂度分析

三种算法在不同规模下运行时间如下表：

在这里插入图片描述

纵坐标单位为(ms)，横坐标单位为(个)。

当问题规模到15000时，暴力算法明显变得笨重；当问题规=规模到达10000000时，分治算法也开始劣于动态规划。

三者的时间复杂度比较：O(n2)>O(nlogn)>O(n)。

源代码

暴力算法：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.Scanner;

public class ziduanhe1 {
    public static int []a = new int[1000000];
    public static void test(int n){
        random_get(n);
        int ThisSum,MaxSum=0;
        for (int i = 0; i < n; i++) {
            ThisSum = 0;
            for (int j = i; j < n; j++) {
                ThisSum+=a[j];
                if (ThisSum>MaxSum){
                    MaxSum = ThisSum;
                }
            }
        }
        System.out.print(MaxSum);
    }
    public static int random_get(int l){
        Random r = new Random();
        int c = 40;
        for (int i = 0; i < l; i++) {
            a[i]= r.nextInt(c)%(2*c+1)-c/2;
        }

        return 0;
    }
    public static void main(String[] args){
        int n;
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            n = sc.nextInt();
//        for (int i = 0; i < n; i++) {
//            a[i] = sc.nextInt();
//        }
//        ziduanhe1 t = new ziduanhe1();
        long startTime = System.currentTimeMillis();
        SimpleDateFormat df = new SimpleDateFormat("\n" + "yyyy-MM-dd HH:mm:ss");
        System.out.println(df.format(new Date()));
        test(n);
        long endTime = System.currentTimeMillis();
        System.out.println(df.format(new Date()));
        System.out.println("\n" + "执行时间" + (endTime - startTime) + "ms");
        }
    }
}

分治算法：

import java.text.SimpleDateFormat;
import java.util.*;
public class ziduanhe2
{
    public static int []a =new int[101000000];
    public static int maxsum(int l,int r){
        if(l==r){
            return a[l];
        }
        int mid = (l+r)/2;
        int lsum = maxsum(l,mid);//左区间
        int rsum = maxsum(mid+1,r);//右区间
        int sum1=0,sum2=0;
        int lefts=0,rights=0;
        for(int i=mid;i>=l;i--){
            lefts+=a[i];
            if(lefts>sum1){
                sum1=lefts;
            }
        }
        for(int i=mid+1;i<=r;i++){
            rights+=a[i];
            if(rights>sum2){
                sum2=rights;
            }
        }
        int msum=sum1+sum2;
        return Math.max(Math.max(lsum,rsum),msum);
    }
    public static int random_get(int l){
        Random r = new Random();
        int c = 40;
        for (int i = 0; i < l; i++) {
            a[i]= r.nextInt(c)%(2*c+1)-c/2;
        }
        return 0;
    }
    public static void main(String[] args){
        int n;
        int ans;
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
            n=in.nextInt();
//            for(int i=1;i<=n;i++){
//                a[i]=in.nextInt();
//            }
            random_get(n);
            long startTime = System.currentTimeMillis();
            SimpleDateFormat df = new SimpleDateFormat("\n"+"yyyy-MM-dd HH:mm:ss");
            System.out.println(df.format(new Date()));
            ans = maxsum(0,n);
            if(ans<0){
                ans=0;
            }
            System.out.println(ans);
            long endTime = System.currentTimeMillis();
            System.out.println(df.format(new Date()));
            System.out.println("\n"+"执行时间"+(endTime-startTime)+"ms");
        }
    }
}

动态规划：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.Scanner;

public class ziduanhe3 {
    public static int []a = new int[101000000];
    public static int maxSum(int n){
        random_get(n);
//        for (int i = 0; i < n; i++) {
//            System.out.print(a[i]);
//        }
        int sum = 0;
        int b = 0;
        for (int i = 0; i < n; i++) {
            if (b>0) b+=a[i];
            else b = a[i];
            if (sum<b) sum = b;
        }
        return sum;
    }
    public static int random_get(int l){
        Random r = new Random();
        int c = 40;
        for (int i = 0; i < l; i++) {
                a[i]= r.nextInt(c)%(2*c+1)-c/2;
            }
        return 0;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n;
        int ans = 0;
        System.out.print("请输入元素个数：");
        while (sc.hasNext()){
            n =sc.nextInt();
//            for (int i = 0; i < n; i++) {
//                a[i] = sc.nextInt();
//            }
            long startTime = System.currentTimeMillis();
            SimpleDateFormat df = new SimpleDateFormat("\n"+"yyyy-MM-dd HH:mm:ss");
            System.out.println(df.format(new Date()));
            ans = maxSum(n);
            if (ans<0){
                ans = 0;
            }
            System.out.print("最大子段和：");
            System.out.print(ans);
            long endTime = System.currentTimeMillis();
            System.out.println(df.format(new Date()));
            System.out.println("\n"+"执行时间"+(endTime-startTime)+"ms");
        }
    }
}
Morefree、
关注
  • 5
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
n个整数的序列：a1，a2，...，an，求最大子段和
11-19
给定n个整数的序列：a1，a2，...，an，求最大子段和
最大子段和的三种求法
Puppet__的博客
10-31 1064
这里注意子段是连续的，子序列是不连续的。 （1）暴力求解 //最大子段和 暴力 直接三层循环 暴力所有区间 然后找最大的子段和 #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cstdio&gt; #include &lt;cmath&gt; #include &lt;cstring&gt; #includ...
MAX SUM 给定由n整数(可能为负数)组成的序列 {a1,a2,…,an}，求该序列形如ai+ai+1,…,+aj的子段和的最大值。当所有的整数均为负数时定义其最大子段和为0。
05-11
Description 给定由n整数(可能为负数)组成的序列 {a1,a2,…,an}，求该序列形如ai+ai+1,…,+aj的子段和的最大值。当所有的整数均为负数时定义其最大子段和为0。 Input 输入包含多组测试数据。第一行为一个整数C，表示有C组测试数据，接下来有2*C行数据，每组测试数据占2行，每组测试数据第一行是1个整数n，表示有n个整数,接下来一行有n个整数,它们之间用空格隔开. Output 你的输出应该有C行，即每组测试数据的输出占一行，它是计算出的最大子段和. Sample Input 1 6 -2 11 -4 13 -5 -2 Sample Output 20
P1115 最大子段和——题解2020.10.2
Cj_fptxbps的博客
10-03 141
P1115 最大子段和 思路分析 一个长度为 n 的序列有很多长短不一的连续子段，子段的位置有前后之分（即子段的第一个值的位置有前后之分）。可以定义一个数组 a[ ] 存放序列的值；数组 b[ ] 存放子段和，下标表示子段的位置，初始化为 n 个长度为 1 的子段，即与序列一样； 从第二个位置开始一直到最后一个位置，如果这个子段的第一个值加上上一个位置的子段和大于它本身，则将此和赋值给该子段和，成为一个更大的新子段，公式表示为：b[ i ] = max(a[ i ], a[ i ] + b[ i - 1
最大子段和问题（3种方法）
热门推荐
weixin_44469806的博客
10-17 3万+
给定由n个整数(可能为负整数)组成的序列a1，a2， a3… ， an， 寻找它的某个连续子段，使得其和最大。例如( -2,11,-4,13,-5,-2 )最大子段是{ 11,-4,13 }其和为20。 1、最大字段和问题的简单算法 (1)枚举法求解： 以a[0]开始: {a[0]}, {a[0],a[1]},{a[0],a[1],a[2]}……{a[0],a[1],……a[n]}共n个 以a[1]开始: {a[1]}, {a[1],a[2]},{a[1],a[2],a[3]}……{a[1],a[2],……
最大子段和（动态规划详细解析）
暴力扬
12-20 3334
给出一个长度为n的序列a，选出其中连续且非空的一段使得这段和最大。
四种方法求解最大子段和问题
weixin_44755413的博客
04-13 8769
题目描述 给定一段长度为n的序列，我们需要找到其中一个连续的子段，使这个子段中各个元素加和最大，如果这个数组中全为负整数，我们就定义这个子段和为0. 题目分析 首先我们的目的是找一个局部的子段但加和是全局最大，所以我们可以很自然地想到，直接暴力法遍历求解即可。 方法一.暴力法求解 我们设置一个i，从第1个位置开始遍历，这个i表示的是我们最大子段的起始位置，然后我们从j=i往后接着遍历，j表示的是...
最大子段和详解（N种解法汇总）
钟晓时
07-26 1万+
问题的提出：给定有n个整数(可能为负整数)组成的序列a1,a2,...,an,求该序列连续的子段和的最大值。如果该序列的所有元素都是负整数时定义其最大子段和为0。例如，当(a1,a2,a3,a4,a5)=(-5,11,-4,13,-4-2)时，最大子段和为11+(-4)+13=20。 解法一：穷举法，即把所有可能情况一一列举穷举法是最直接的想法，把所有的情况列出来，再进行挑选。
最大子段和的四种算法
隔壁家的程序员小白
11-08 3750
最大子段和的算法优化一、例题：二、算法1.暴力算法(时间复杂度：O(N^3)2.暴力算法的改进(时间复杂度：O(N^2))3.分治算法(时间复杂度：O(nlogn))4.动态规划(时间复杂度：O(n)) 一、例题： 注意: 字段和必须是在数组下标连续的元素之和，数组下标不能跳跃。 二、算法 1.暴力算法(时间复杂度：O(N^3) 思路：从第一个元素开始，到最后元素结束，求出这中间的最大字段和； 从第二个元素开始，到最后元素结束，求出这中间的最大字段和，再与已求的最大字段和比较。 …… 从第n个元素开始，
最大子段求和
qq_47461884的博客
04-29 1464
3种算法：最大子段求和 一、问题分析 问题：给定有n个整数(可能为负整数)组成的序列a1,a2,...,an,a_1,a_2,...,a_n,a1​,a2​,...,an​,求该序列连续的子段和的最大值。 如果该子段的所有元素和是负整数时定义其最大子段和为0。 简易算法： 两层循环遍历全部可能值，找出最大的记录下来。先从 iii 加到 jjj 如果出现负数，同时记录当前循环的最大值，并且 j++j++j++；然后再 i++i++i++ 进行下一趟遍历，找可能的最大值。 分治算法： 在序列中间对问题进行划分，
python实现最大子段和算法
02-08
python实现最大子段和算法
分治算法 最大子段和 MATLAB代码
09-04
%divide——将数组分成两段 %conquer——每段分别求最大字段和 %combine——最大子段和无非三种情况：左端、右端、横跨中间 %每段分别求最大子段和的时候采用递归调用
最大子段和问题、算法实现
10-25
C 最大子段和问题的各种算法具体实现！经典算法！
最大子段和问题的三种算法
11-05
分别用蛮力法、分治法、动态规划法设计的最大子段和问题的算法。用VC++ 6.0运行。
java数百种算法实现
06-03
java数百种算法实现
洛谷【入门1】顺序结构
weixin_69583420的博客
04-12 598
洛谷【入门1】顺序结构——python
快速排序算法
m0_68821222的博客
04-13 585
快速排序的最坏情况是O(n^2)，比如说顺序 数列的快排。但它的平均期望是O(nlogn)，且(nlogn)记号中隐含的常数因子很小，比复杂度稳定等于O(nlogn)的归并排序要小很多，所以，对绝大数顺序性较弱的随机数列而言，快速排序总要优于归并排序。2.重新排序数列，所有比基准值小的放在基准前面，所有元素比基准大的放在基准后面。（相同的数可以到任一边）。3.递归（recursive）把小于基准值元素的子数列和大于基准元素的子数列排序。1.从数列中挑出一个元素，称为“基准”，（pivot）。
C++ | Leetcode C++题解之第27题移除元素
最新发布
Ddddddd_158的博客
04-14 436
C++ | Leetcode C++题解之第27题移除元素
相似图片分类 [华为]【并查集】
weixin_45619734的博客
04-11 468
给定一个大小为N×N的矩阵M存储任意两张图片的相似度，M[i][j]即为第i个图片和第j个图片的相似度，请按照“从大到小”的顺序返回每个相似类。下面跟着N行，每行有N列数据，空格分隔（为了显示整齐，空格可能为多个），代表N个图片之间的相似度。2）如果A和B相似，B和C相似，但A和C不相似，那么认为A和C间接相似，可以把ABC归为一类，但不计算AC的相似度；小明想要处理一批图片，将相似的图片分类，他首先对图片的特征采样，得到图片之间的相似度，然后。每个相似类的相似度之和。中所有图片的相似度之和。
最长公共子序列问题和最大子段和问题的动态规划算法实现和效率分析
04-27
最长公共子序列问题和最大子段和问题都是动态规划问题。 1. 最长公共子序列问题 最长公共子序列问题（Longest Common Subsequence, LCS）是指给定两个序列X和Y，找出它们的最长公共子序列。 动态规划算法实现： 设X={x1,x2,…,xm}和Y={y1,y2,…,yn}，令c[i][j]表示X的前i个字符和Y的前j个字符的LCS长度，b[i][j]记录c[i][j]是由哪一个子问题的解得到的。 则有以下的状态转移方程： c[i][j] = 0, i=0 或 j=0 c[i][j] = c[i-1][j-1]+1, i,j>0 且 xi=yj c[i][j] = max(c[i-1][j], c[i][j-1]), i,j>0 且 xi≠yj 实现代码如下： ```python def LCS(X, Y): m, n = len(X), len(Y) c = [[0]*(n+1) for i in range(m+1)] b = [[0]*(n+1) for i in range(m+1)] for i in range(1, m+1): for j in range(1, n+1): if X[i-1] == Y[j-1]: c[i][j] = c[i-1][j-1] + 1 b[i][j] = '↖' elif c[i-1][j] >= c[i][j-1]: c[i][j] = c[i-1][j] b[i][j] = '↑' else: c[i][j] = c[i][j-1] b[i][j] = '←' return c, b def printLCS(b, X, i, j): if i == 0 or j == 0: return if b[i][j] == '↖': printLCS(b, X, i-1, j-1) print(X[i-1], end='') elif b[i][j] == '↑': printLCS(b, X, i-1, j) else: printLCS(b, X, i, j-1) ``` 效率分析： 设X和Y的长度分别为m和n，时间复杂度为O(mn)，空间复杂度也为O(mn)。 2. 最大子段和问题 最大子段和问题（Maximum Subarray Sum）是指在一个数列中找到一个连续的子序列，使得该子序列的和最大。 动态规划算法实现： 设a[1..n]为输入的数组，sum[i]表示以a[i]为结尾的最大子段和，则有以下的状态转移方程： sum[1] = a[1] sum[i] = max(sum[i-1]+a[i], a[i]), i>1 实现代码如下： ```python def maxSubarray(a): n = len(a) dp = [0] * n dp[0] = a[0] for i in range(1, n): dp[i] = max(dp[i-1] + a[i], a[i]) return max(dp) ``` 效率分析： 设a的长度为n，时间复杂度为O(n)，空间复杂度为O(n)。 综上所述，最长公共子序列问题和最大子段和问题的动态规划算法都是时间复杂度为O(n^2)，空间复杂度为O(n^2)的算法，但是两者的状态转移方程和实现方式不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值