Maximum Sum of Subsequence With Non-adjacent Elements

Maximum Sum of Subsequence With Non-adjacent Elements - Problem

You are given an array nums consisting of integers. You are also given a 2D array queries, where queries[i] = [pos_i, x_i].

For query i, we first set nums[pos_i] equal to x_i, then we calculate the answer to query i which is the maximum sum of a subsequence of nums where no two adjacent elements are selected.

Return the sum of the answers to all queries. Since the final answer may be very large, return it modulo 10^9 + 7.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,1], queries = [[1,10],[3,5]]

› Output: 26

💡 Note: Query [1,10]: nums=[1,10,3,1]. DP: dp[0]=1, dp[1]=10, dp[2]=max(10,1+3)=10, dp[3]=max(10,10+1)=11. Query [3,5]: nums=[1,10,3,5]. DP: dp[0]=1, dp[1]=10, dp[2]=10, dp[3]=max(10,10+5)=15. Total=11+15=26

Example 2 — Single Element

$ Input: nums = [5], queries = [[0,2],[0,7]]

› Output: 9

💡 Note: After query [0,2]: nums = [2], max sum = 2. After query [0,7]: nums = [7], max sum = 7. Total = 2 + 7 = 9.

Example 3 — All Negative

$ Input: nums = [-1,-2], queries = [[0,1],[1,3]]

› Output: 4

💡 Note: After query [0,1]: nums = [1,-2], max sum = 1 (take first element). After query [1,3]: nums = [1,3], max sum = 3 (take second element, as taking both would violate adjacency). Actually max sum = max(1,3) = 3. Wait, let me recalculate. For [1,3]: we can't take both since they're adjacent. So max sum = max(1,3) = 3. Total = 1 + 3 = 4.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ queries.length ≤ 5 × 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
0 ≤ pos_i < nums.length
-10⁵ ≤ x_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Meta 4

This problem combines the classic House Robber dynamic programming pattern with multiple updates. The key insight is that each query requires recalculating the maximum sum of non-adjacent elements after updating the array. The naive approach runs DP for each query in O(q×n) time. For better performance with many queries, a segment tree approach maintaining both 'include' and 'exclude' states for each range would achieve O(q×log n) time complexity.

Common Approaches

✓ Brute Force - Recalculate DP for Each Query

⏱️ Time: O(q × n) Space: O(n)

For each query, update the array at the specified position, then run a complete dynamic programming solution to find the maximum sum of non-adjacent elements. Sum all query results.

Dynamic Programming Optimization

⏱️ Time: O(q × n) Space: O(1)

Use dynamic programming with space optimization. Instead of storing entire DP array, keep track of only previous two values. Still recalculate for each query but with better space efficiency.

Brute Force - Recalculate DP for Each Query — Algorithm Steps

For each query, update nums[pos] = x
Run DP: dp[i] = max(dp[i-1], dp[i-2] + nums[i])
Add result to total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Array

Set nums[pos] = x for current query

Run DP

Calculate dp[i] = max(dp[i-1], dp[i-2] + nums[i])

Add Result

Add dp[n-1] to total sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007

long long max_ll(long long a, long long b) {
    return a > b ? a : b;
}

int max_int(int a, int b) {
    return a > b ? a : b;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseQueries(const char* str, int queries[][2], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            p++;
            queries[*size][0] = (int)strtol(p, (char**)&p, 10);
            while (*p == ' ' || *p == ',') p++;
            queries[*size][1] = (int)strtol(p, (char**)&p, 10);
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            (*size)++;
        } else {
            p++;
        }
    }
}

int solution(int* nums, int numsSize, int queries[][2], int queriesSize) {
    long long totalSum = 0;
    
    for (int q = 0; q < queriesSize; q++) {
        int pos = queries[q][0];
        int x = queries[q][1];
        nums[pos] = x;
        
        int n = numsSize;
        if (n == 0) continue;
        if (n == 1) {
            totalSum = (totalSum + max_int(0, nums[0])) % MOD;
            continue;
        }
        
        long long* dp = (long long*)malloc(n * sizeof(long long));
        dp[0] = nums[0];
        dp[1] = max_ll(nums[0], nums[1]);
        
        for (int i = 2; i < n; i++) {
            dp[i] = max_ll(dp[i-1], dp[i-2] + nums[i]);
        }
        
        long long result = max_ll(0, dp[n-1]);
        totalSum = (totalSum + result) % MOD;
        free(dp);
    }
    
    return totalSum;
}

int main() {
    char line[1000];
    int nums[100];
    int queries[100][2];
    int numsSize, queriesSize;
    
    fgets(line, sizeof(line), stdin);
    parseArray(line, nums, &numsSize);
    
    fgets(line, sizeof(line), stdin);
    parseQueries(line, queries, &queriesSize);
    
    printf("%d\n", solution(nums, numsSize, queries, queriesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

q queries, each requiring O(n) DP calculation

✓ Linear Growth

Space Complexity

O(n)

DP array of size n to store intermediate results

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Recalculate DP for Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler