What is the main pattern behind Maximum Ascending Subarray Sum?

The pattern is a one-pass array scan over contiguous increasing runs. You keep adding while nums[i] > nums[i-1], and when that condition fails, you reset the running sum to start a new run.

Why is the answer 65 for nums = [10,20,30,5,10,50]?

The ascending runs are [10,20,30] with sum 60 and [5,10,50] with sum 65. Since the second strictly increasing contiguous run has the larger sum, the result is 65.

Why is this not an increasing subsequence problem?

Because the problem asks for a subarray, which must be contiguous. You cannot skip elements, so once the ascending order breaks between adjacent positions, that run is over.

Can I solve this by checking all subarrays?

Yes, the constraints are small enough that brute force can pass. But the intended trade-off is recognizing that only contiguous rising runs matter, which gives a simpler O(n) solution with constant extra space.

What breaks the current run in this array pattern?

Any position where nums[i] <= nums[i-1] ends the current strictly increasing subarray. At that point, the new current sum must restart from nums[i] rather than continue across the break.

#1800

Easy

auto_awesome数组·driven

LeetCode 题解工作台

最大升序子数组和

给你一个正整数组成的数组 nums ，返回 nums 中一个严格递增子数组的最大可能元素和。子数组是数组中的一个连续数字序列。示例 1：输入： nums = [10,20,30,5,10,50] 输出： 65 解释： [5,10,50] 是元素和最大的升序子数组，最大元素和为 65 。示…

数组

题目描述

给你一个正整数组成的数组 nums ，返回 nums 中一个严格递增子数组的最大可能元素和。

子数组是数组中的一个连续数字序列。

示例 1：

输入：nums = [10,20,30,5,10,50]
输出：65
解释：[5,10,50] 是元素和最大的升序子数组，最大元素和为 65 。

示例 2：

输入：nums = [10,20,30,40,50]
输出：150
解释：[10,20,30,40,50] 是元素和最大的升序子数组，最大元素和为 150 。

示例 3：

输入：nums = [12,17,15,13,10,11,12]
输出：33
解释：[10,11,12] 是元素和最大的升序子数组，最大元素和为 33 。

提示：

1 <= nums.length <= 100
1 <= nums[i] <= 100

lightbulb

解题思路

方法一：直接模拟

我们用变量 $t$ 记录当前升序子数组的和，用变量 $ans$ 记录最大的升序子数组和。

遍历数组 $nums$ ：

如果当前元素是数组的第一个元素，或者当前元素大于前一个元素，那么将当前元素加入到当前升序子数组的和，即 $t = t + nums[i]$ ，并且更新最大升序子数组和 $ans = \max(ans, t)$ ；否则，当前元素不满足升序子数组的条件，那么将当前升序子数组的和 $t$ 重置为当前元素，即 $t = nums[i]$ 。

遍历结束，返回最大升序子数组和 $ans$ 。

时间复杂度 $O(n)$ ，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$ 。

1

2

3

4

5

6

7

8

9

10

11

class Solution:
    def maxAscendingSum(self, nums: List[int]) -> int:
        ans = t = 0
        for i, v in enumerate(nums):
            if i == 0 or v > nums[i - 1]:
                t += v
                ans = max(ans, t)
            else:
                t = v
        return ans

speed

复杂度分析

指标	值
时间	O(n)
空间	O(1)

psychology

面试官常问的追问

外企场景

question_mark
The interviewer emphasizes contiguous subarray, which points to tracking runs instead of searching arbitrary subsequences.
question_mark
The constraint that values are positive makes the running-sum reset logic especially straightforward when an ascending streak breaks.
question_mark
A hint like "fast enough to check all possible subarrays" often tests whether you can notice the simpler one-pass property of maximal increasing runs.

warning

常见陷阱

外企场景

error
Using >= instead of >, which incorrectly merges equal adjacent values into an ascending run.
error
Thinking this is about the longest or maximum-sum increasing subsequence, even though the subarray must remain contiguous.
error
Forgetting to update the best sum after extending a run, which can miss answers in a fully increasing array such as [10,20,30,40,50].

swap_horiz

进阶变体

外企场景

arrow_right_alt
Return the actual ascending subarray with the maximum sum instead of only the sum, which requires tracking the run start and best segment bounds.
arrow_right_alt
Change the rule to non-decreasing subarray sum, where the comparison becomes >= and equal neighbors no longer break the run.
arrow_right_alt
Ask for the maximum product of a strictly increasing contiguous subarray, which changes the state update even though the run-breaking logic stays similar.

help

常见问题

外企场景

继续练习

#1799 N 次操作后的最大分数和 #1801 积压订单中的订单总数 #1798 你能构造出连续值的最大数目