动态规划-求最大连续子序列累加和

本文介绍了如何使用动态规划解决最大连续子序列累加和问题,定义了dp[i]的含义,并给出了Java代码实现,详细讲解了dp方程和解题思路。代码实现可在GitHub上的个人项目中找到。
摘要由CSDN通过智能技术生成

经典动态规划问题

  1. 定义dp[i]的意义:表示以i为下标结束的最大连续累加和
  2. 定义dp方程:dp[n] = max(dp[n-1] + a[i], a[i]);
  3. 最大连续累加和就在dp[n]中取得 res = max(dp[n],res);

Java 代码实现

package com.study.dynamic;

import java.util.Objects;

/**
 *
 * 给定一组数组 求出连续子序列的最大累加值
 * 定义dp[n]数组在n位置的最大累加值
 * 则dp方程:dp[n] = max(dp[n-1]+a[n], a[n])
 * 最大值就在各个dp[n]中取得
 */
public class MaxSumResult {
   

    public static void main(String[] args){
   
        int[] origin = 
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是四种常用方法一个序列最大连续子序列的和: 1. 蛮力法:对于每一个子序列,计算它们的和,最后找出最大值。时间复杂度为 O(n^2)。 ```python def max_subarray_sum_brute_force(nums): n = len(nums) max_sum = float("-inf") for i in range(n): cur_sum = 0 for j in range(i, n): cur_sum += nums[j] max_sum = max(max_sum, cur_sum) return max_sum ``` 2. 分治法:将序列分成左右两部分,分别左部分、右部分和跨越中点的最大子序列和,最后将三个值取最大值。时间复杂度为 O(nlogn)。 ```python def max_subarray_sum_divide_conquer(nums): n = len(nums) def max_crossing_sum(nums, left, mid, right): left_max_sum = float("-inf") cur_sum = 0 for i in range(mid, left-1, -1): cur_sum += nums[i] left_max_sum = max(left_max_sum, cur_sum) right_max_sum = float("-inf") cur_sum = 0 for i in range(mid+1, right+1): cur_sum += nums[i] right_max_sum = max(right_max_sum, cur_sum) return left_max_sum + right_max_sum def max_subarray_sum(nums, left, right): if left == right: return nums[left] mid = (left + right) // 2 left_max_sum = max_subarray_sum(nums, left, mid) right_max_sum = max_subarray_sum(nums, mid+1, right) crossing_max_sum = max_crossing_sum(nums, left, mid, right) return max(left_max_sum, right_max_sum, crossing_max_sum) return max_subarray_sum(nums, 0, n-1) ``` 3. 动态规划法:定义一个变量 cur_sum,用来记录当前的连续子序列和,如果 cur_sum 小于等于 0,则从下一个元素重新开始计算,否则继续累加。用一个变量 max_sum 记录最大连续子序列和。时间复杂度为 O(n)。 ```python def max_subarray_sum_dp(nums): n = len(nums) cur_sum = nums[0] max_sum = nums[0] for i in range(1, n): cur_sum = max(cur_sum + nums[i], nums[i]) max_sum = max(max_sum, cur_sum) return max_sum ``` 4. Kadane算法:与动态规划法类似,但只需要一个变量 cur_sum 来记录当前的连续子序列和,不需要用一个变量 max_sum 记录最大连续子序列和,而是在每次更新 cur_sum 的时候,同时更新最大值。时间复杂度为 O(n)。 ```python def max_subarray_sum_kadane(nums): n = len(nums) cur_sum = nums[0] max_sum = nums[0] for i in range(1, n): cur_sum = max(nums[i], cur_sum + nums[i]) max_sum = max(max_sum, cur_sum) return max_sum ``` 这四种方法的时间复杂度分别为 O(n^2)、O(nlogn)、O(n) 和 O(n),其中 Kadane算法 是最优的。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值