Handling Sum Queries After Update

Handling Sum Queries After Update - Problem

You are given two 0-indexed arrays nums1 and nums2 and a 2D array queries of queries. There are three types of queries:

Type 1: queries[i] = [1, l, r]. Flip the values from 0 to 1 and from 1 to 0 in nums1 from index l to index r (both inclusive).

Type 2: queries[i] = [2, p, 0]. For every index 0 <= i < n, set nums2[i] = nums2[i] + nums1[i] * p.

Type 3: queries[i] = [3, 0, 0]. Find the sum of all elements in nums2.

Return an array containing all the answers to the third type queries.

Input & Output

Example 1 — Basic Operations

$ Input: nums1 = [1,0,1], nums2 = [0,0,0], queries = [[1,1,1],[2,1,0],[3,0,0]]

› Output: [3]

💡 Note: Query [1,1,1]: flip nums1[1] from 0→1, so nums1=[1,1,1]. Query [2,1,0]: add nums1[i]*1 to nums2[i], so nums2=[1,1,1]. Query [3,0,0]: sum of nums2 = 1+1+1 = 3.

Example 2 — Multiple Sum Queries

$ Input: nums1 = [1,0,1,0], nums2 = [1,2,3,4], queries = [[3,0,0],[2,3,0],[3,0,0],[1,0,3],[3,0,0]]

› Output: [10,16,16]

💡 Note: Initial sum=10. After [2,3,0]: add nums1[i]*3 to each nums2[i], giving [4,2,6,4], sum=16. After [1,0,3]: flip nums1[0:3] from [1,0,1,0] to [0,1,0,0], but nums2 remains [4,2,6,4], sum=16.

Example 3 — Range Flip Edge Case

$ Input: nums1 = [1], nums2 = [5], queries = [[2,2,0],[3,0,0],[1,0,0],[2,3,0],[3,0,0]]

› Output: [7,7]

💡 Note: [2,2,0]: nums2[0] += 1*2 = 7. [3,0,0]: sum=7. [1,0,0]: flip nums1[0] to 0. [2,3,0]: add 0*3=0. [3,0,0]: sum=7.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
0 ≤ nums1[i] ≤ 1
1 ≤ nums2[i] ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
queries[i].length == 3
1 ≤ queries[i][0] ≤ 3
For queries of type 1: 0 ≤ l ≤ r < nums1.length
For queries of type 2: 1 ≤ p ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 M Microsoft 3

The key insight is to avoid recalculating the entire nums2 array for type 2 queries by tracking only the count of 1s in nums1 and maintaining the sum of nums2. Best approach uses count-based optimization for O(1) type 2 and type 3 queries. Time: O(q × n), Space: O(1)

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 2d

⏱️ Time: N/A Space: N/A

Brute Force

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

For each query, perform the operation exactly as described: flip ranges in nums1, update all elements in nums2, or sum nums2. This is straightforward but inefficient for large inputs.

Count-Based Optimization

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

Instead of maintaining the actual bits in nums1, we only track how many 1s there are. For type 2 queries, we can compute the total addition as count_of_ones * p. This avoids the O(n) iteration for type 2 queries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_LEN 201

int memo[MAX_LEN][MAX_LEN][MAX_LEN*2];
bool memo_set[MAX_LEN][MAX_LEN][MAX_LEN*2];

bool backtrack(char* s1, char* s2, char* s3, int i, int j, int k, int len1, int len2, int len3) {
    if (k == len3) {
        return i == len1 && j == len2;
    }
    
    if (memo_set[i][j][k]) {
        static return memo[i][j][k];
    }
    
    bool result = false;
    if (i < len1 && s1[i] == s3[k]) {
        result = backtrack(s1, s2, s3, i + 1, j, k + 1, len1, len2, len3);
    }
    if (!result && j < len2 && s2[j] == s3[k]) {
        result = backtrack(s1, s2, s3, i, j + 1, k + 1, len1, len2, len3);
    }
    
    memo[i][j][k] = result;
    memo_set[i][j][k] = true;
    return result;
}

bool solution(char* s1, char* s2, char* s3) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int len3 = strlen(s3);
    
    if (len1 + len2 != len3) {
        return false;
    }
    
    memset(memo_set, false, sizeof(memo_set));
    return backtrack(s1, s2, s3, 0, 0, 0, len1, len2, len3);
}

int main() {
    char s1[1001] = {0}, s2[1001] = {0}, s3[1001] = {0};
    
    // Read first line
    if (fgets(s1, sizeof(s1), stdin) != NULL) {
        s1[strcspn(s1, "\n")] = 0;
    }
    
    // Read second line  
    if (fgets(s2, sizeof(s2), stdin) != NULL) {
        s2[strcspn(s2, "\n")] = 0;
    }
    
    // Read third line
    if (fgets(s3, sizeof(s3), stdin) != NULL) {
        s3[strcspn(s3, "\n")] = 0;
    }
    
    bool result = solution(s1, s2, s3);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.8K Views

Medium Frequency

~35 min Avg. Time

485 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