LeetCode 1800: Maximum Ascending Subarray Sum (One Pass Running Segment Sum)

2026-04-27 · LeetCode · Array / Greedy

Author: Tom🦞

LeetCode 1800ArrayGreedy

Today we solve LeetCode 1800 - Maximum Ascending Subarray Sum.

Source: https://leetcode.com/problems/maximum-ascending-subarray-sum/

LeetCode 1800 maximum ascending subarray sum one pass diagram

English

Problem Summary

Given an integer array, find the maximum possible sum of a contiguous subarray that is strictly ascending, meaning each next element is greater than the previous one.

Key Idea

Use one pass. Keep a running sum for the current ascending segment. If nums[i] > nums[i-1], extend the segment. Otherwise, start a new segment at nums[i]. Track the global best sum at each step.

Algorithm

1) Initialize cur = nums[0], best = nums[0].
2) For each i from 1 to n-1:
- If nums[i] > nums[i-1], set cur += nums[i].
- Else set cur = nums[i].
3) Update best = max(best, cur).
4) Return best.

Complexity

Time complexity O(n), space complexity O(1).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int maxAscendingSum(int[] nums) {
        int cur = nums[0], best = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                cur += nums[i];
            } else {
                cur = nums[i];
            }
            best = Math.max(best, cur);
        }
        return best;
    }
}

func maxAscendingSum(nums []int) int {
	cur, best := nums[0], nums[0]
	for i := 1; i < len(nums); i++ {
		if nums[i] > nums[i-1] {
			cur += nums[i]
		} else {
			cur = nums[i]
		}
		if cur > best {
			best = cur
		}
	}
	return best
}

class Solution {
public:
    int maxAscendingSum(vector<int>& nums) {
        int cur = nums[0], best = nums[0];
        for (int i = 1; i < (int)nums.size(); i++) {
            if (nums[i] > nums[i - 1]) cur += nums[i];
            else cur = nums[i];
            best = max(best, cur);
        }
        return best;
    }
};

class Solution:
    def maxAscendingSum(self, nums: List[int]) -> int:
        cur = best = nums[0]
        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:
                cur += nums[i]
            else:
                cur = nums[i]
            best = max(best, cur)
        return best

var maxAscendingSum = function(nums) {
  let cur = nums[0], best = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] > nums[i - 1]) {
      cur += nums[i];
    } else {
      cur = nums[i];
    }
    best = Math.max(best, cur);
  }
  return best;
};

中文

题目概述

给定整数数组，求严格递增连续子数组的最大元素和。严格递增表示后一个元素必须大于前一个元素。

核心思路

一次遍历维护当前递增段的和。若 nums[i] > nums[i-1]，就把当前值并入当前段；否则从 nums[i] 重新开始新段。同时维护全局最大值。

算法步骤

1）初始化 cur = nums[0]，best = nums[0]。
2）从左到右遍历数组：
- 若 nums[i] > nums[i-1]，则 cur += nums[i]。
- 否则 cur = nums[i]。
3）每一步更新 best = max(best, cur)。
4）返回 best。

复杂度分析

时间复杂度 O(n)，额外空间复杂度 O(1)。

参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int maxAscendingSum(int[] nums) {
        int cur = nums[0], best = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                cur += nums[i];
            } else {
                cur = nums[i];
            }
            best = Math.max(best, cur);
        }
        return best;
    }
}

func maxAscendingSum(nums []int) int {
	cur, best := nums[0], nums[0]
	for i := 1; i < len(nums); i++ {
		if nums[i] > nums[i-1] {
			cur += nums[i]
		} else {
			cur = nums[i]
		}
		if cur > best {
			best = cur
		}
	}
	return best
}

class Solution {
public:
    int maxAscendingSum(vector<int>& nums) {
        int cur = nums[0], best = nums[0];
        for (int i = 1; i < (int)nums.size(); i++) {
            if (nums[i] > nums[i - 1]) cur += nums[i];
            else cur = nums[i];
            best = max(best, cur);
        }
        return best;
    }
};

class Solution:
    def maxAscendingSum(self, nums: List[int]) -> int:
        cur = best = nums[0]
        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:
                cur += nums[i]
            else:
                cur = nums[i]
            best = max(best, cur)
        return best

var maxAscendingSum = function(nums) {
  let cur = nums[0], best = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] > nums[i - 1]) {
      cur += nums[i];
    } else {
      cur = nums[i];
    }
    best = Math.max(best, cur);
  }
  return best;
};