Resilient Subsequence Sum — Problem Statement & Solution Guide

RecursionEasyBacktracking Path

TimeO(n)

SpaceO(1)

Problem Description

In distributed computing systems, data integrity is often maintained by identifying the most stable subset of sequential metrics. You are provided with an array of integers representing a time-series log of system health scores. Your task is to compute the 'Resilient Subsequence Sum', defined as the maximum possible sum of a subsequence derived from the input array. A subsequence is formed by selecting zero or more elements from the original array while preserving their relative order, but not necessarily their contiguity. The goal is to identify the selection of elements that yields the highest aggregate value, effectively filtering out negative impacts on the total sum. If all elements in the array are negative, the resilient subsequence sum is defined as the maximum single element (the least negative value), as selecting no elements is not considered a valid non-empty subsequence in this context.

DSA Pattern Breakdown

"Resilient Subsequence Sum"

easy

WHY DOES IT MATTER?

Understanding the maximum‑subsequence pattern teaches candidates to differentiate between contiguous and non‑contiguous selections, a nuance that appears in many optimization problems and influences the choice of greedy versus DP solutions.

OPTIMIZATION CHALLENGE

The key insight is that each element’s contribution is independent of others—positive numbers always help, negatives never do—allowing a single linear pass without auxiliary data structures.

REAL-WORLD CONNECTION

In distributed monitoring, you often need the healthiest set of metrics to trigger alerts; you sum only the positive health scores while ignoring degradations, mirroring the subsequence sum logic.

During an interview, first state the greedy observation, then immediately handle the all‑negative edge case; this shows you can reason about both the common path and corner cases efficiently.

COMPLEXITY AT A GLANCE

⏱ Time:O(n)

💾 Space:O(1)

Core Theory — Why This Approach?

The Resilient Subsequence Sum problem asks for the maximum possible sum obtainable by selecting any subset of elements from an array while preserving their original order. Because the subsequence does not need to be contiguous, the optimal choice is straightforward: include every element that contributes positively to the total and discard the negatives. This observation reduces the problem to a simple linear scan where we accumulate all positive numbers. However, a subtle edge case appears when every element is negative; in that scenario, the best we can do is pick the single largest (least negative) element, because any longer subsequence would only decrease the sum.

A naïve exhaustive search would enumerate all 2^n possible subsequences, compute each sum, and keep the maximum. Such exponential time quickly becomes infeasible even for moderate n (e.g., n = 30 leads to over a billion combinations). The optimal paradigm leverages greedy reasoning combined with a single pass: the decision to include an element depends only on its sign and the current global best, not on future elements. This yields an O(n) time, O(1) extra‑space solution that scales to the massive logs typical in distributed systems.

Interview Questions on This Problem

Q1How would you compute the maximum subsequence sum for an array that may contain both positive and negative integers?

Iterate once through the array, adding each positive number to a running total. Keep track of the maximum element seen; if all numbers are negative, return that maximum. Otherwise, return the accumulated total of positives.

Q2Why does the classic Kadane’s algorithm for maximum subarray sum not apply directly to this problem?

Kadane’s algorithm solves the contiguous subarray version, where elements must be adjacent. In the subsequence version we can skip any elements, so the optimal solution is simply the sum of all positives (or the largest negative), which Kadane’s DP recurrence does not capture.

Q3What edge case must you handle when all numbers in the input are negative, and how do you implement it?

When every element is negative, the sum of positives would be zero, which is not a valid subsequence. You must track the maximum (least negative) value during the scan and return it if no positive numbers were encountered.

Examples

Example 1

Input

nums = [3, -1, 4, -1, 5]

Output

Explanation: The optimal subsequence is [3, 4, 5]. By skipping the negative values (-1), the sum is 3 + 4 + 5 = 12. Any other combination yields a lower sum.

Example 2

Input

nums = [-2, -3, -1, -5]

Output

-1

Explanation: All elements are negative. The maximum sum is achieved by selecting the single largest element, which is -1. Selecting multiple elements would result in a smaller (more negative) sum.

Example 3

Input

nums = [1, 2, 3, 4, 5]

Output

Explanation: All elements are positive. The optimal subsequence includes all elements: 1 + 2 + 3 + 4 + 5 = 15.

Example 4

Input

nums = [5, -10, 5, -10, 5]

Output

Explanation: The optimal subsequence is [5, 5, 5]. Skipping the -10s results in a sum of 15. Including any -10 would reduce the total.

Constraints

1 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9
The sum of all elements in the array may exceed 32-bit integer range, so use 64-bit integer for accumulation.

Optimal Approach & Strategy

Traverse the array once, summing positive numbers and tracking the maximum element; return the sum if any positive exists, otherwise return the maximum element.

Brute Force Approach

Generate all 2^n possible subsequences, compute each sum, and keep the maximum; this exponential method is impractical for large n.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(n)

function solution(nums) {
   let n = nums.length;
   let dp = new Array(n).fill(0);
   dp[0] = nums[0];
   let maxSum = dp[0];
   for (let i = 1; i < n; i++) {
       dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
       maxSum = Math.max(maxSum, dp[i]);
   }
   return maxSum;
}

class Solution {
   public:
       int solution(vector<int>& nums) {
           int n = nums.size();
           vector<int> dp(n);
           dp[0] = nums[0];
           int maxSum = dp[0];
           for (int i = 1; i < n; i++) {
               dp[i] = max(dp[i - 1] + nums[i], nums[i]);
               maxSum = max(maxSum, dp[i]);
           }
           return maxSum;
       }
   };

class Solution {
   public int solution(int[] nums) {
       int n = nums.length;
       int[] dp = new int[n];
       dp[0] = nums[0];
       int maxSum = dp[0];
       for (int i = 1; i < n; i++) {
           dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
           maxSum = Math.max(maxSum, dp[i]);
       }
       return maxSum;
   }
}

def solution(nums):
   n = len(nums)
   dp = [0] * n
   dp[0] = nums[0]
   max_sum = dp[0]
   for i in range(1, n):
       dp[i] = max(dp[i - 1] + nums[i], nums[i])
       max_sum = max(max_sum, dp[i])
   return max_sum

function solution(nums) {
   let n = nums.length;
   let dp = new Array(n).fill(0);
   dp[0] = nums[0];
   let maxSum = dp[0];
   for (let i = 1; i < n; i++) {
       dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
       maxSum = Math.max(maxSum, dp[i]);
   }
   return maxSum;
}

Asked in Top Tech Interviews

PhonePeWipro

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Resilient Subsequence Sum Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Input

Output

Constraints

More Recursion

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Resilient Subsequence Sum — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor