Handling Sum Queries After Update - Practice Coding Problems

Handling Sum Queries After Update - Problem

You're tasked with managing two dynamic arrays and handling three types of operations efficiently. Given two 0-indexed arrays nums1 and nums2, along with a series of queries, you need to process operations that can:

Type 1: Flip all bits in a range of nums1 (0→1, 1→0) from index l to r
Type 2: Update all elements in nums2 by adding nums1[i] * p to each nums2[i]
Type 3: Calculate and return the sum of all elements in nums2

Your goal is to return an array containing the answers to all Type 3 queries in the order they appear. This problem tests your ability to handle range updates and efficient sum calculations with potential optimizations using advanced data structures.

Key Challenge: With potentially large arrays and many queries, a naive approach might be too slow. Consider how segment trees or lazy propagation can optimize range operations!

Input & Output

example_1.py — Basic Operations

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

› Output: [1]

💡 Note: After query [1,1,1]: nums1 = [1,1,1,0]. After query [2,1,0]: nums2 = [1,1,1,0] (each nums2[i] += nums1[i] * 1). After query [3,0,0]: sum = 1+1+1+0 = 3. But since there's only one type 3 query, return [3] would be expected, but the example shows [1] which seems incorrect.

example_2.py — Multiple Queries

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

› Output: [8,14]

💡 Note: Initial: nums1=[1,0,1], nums2=[2,3,1]. After [2,3,0]: nums2=[2+1*3,3+0*3,1+1*3]=[5,3,4]. Query [3,0,0]: sum=5+3+4=12. After [1,0,2]: nums1=[0,1,0]. Query [3,0,0]: sum=12 (nums2 unchanged). Result: [12,12]

example_3.py — Edge Case

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

› Output: [5,5]

💡 Note: Initial sum is 5. After flipping nums1[0] from 1 to 0, nums2 remains unchanged since no type 2 query follows. Both type 3 queries return the same sum of 5.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Build Control System

Create a hierarchical control system (segment tree) to manage traffic lights efficiently

Range Operations

When updating light ranges, use lazy propagation to avoid individual updates

Traffic Flow Update

Calculate traffic impact by counting green lights and updating total flow

Report Statistics

Instantly return maintained total without recalculating

Key Takeaway

🎯 Key Insight: Use segment trees with lazy propagation for efficient range updates, and maintain the sum mathematically instead of recalculating from scratch

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a Segment Tree with Lazy Propagation to handle range flips efficiently in O(log n) time, while maintaining the sum of nums2 as a single variable that gets updated mathematically during type 2 operations. This achieves O(q * log n) overall time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Segment Tree with Lazy Propagation (Optimal)	O(q * log n)	O(n)	Use segment tree for efficient range updates and maintain sum of nums2 separately
Brute Force (Direct Simulation)	O(q * n)	O(1)	Directly simulate each operation by updating arrays element by element

Segment Tree with Lazy Propagation (Optimal) — Algorithm Steps

Build a segment tree for nums1 to handle range flip operations
Implement lazy propagation to avoid updating individual elements immediately
Maintain count of 1s in nums1 using the segment tree
For type 2 queries, update sum of nums2 using: sum += count_of_ones * p
For type 3 queries, return the maintained sum directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create segment tree from nums1 to track sum of 1s

Range Flip

Use lazy propagation to mark ranges for flipping

Update Sum

Calculate nums2 sum using count of 1s from tree

Query Result

Return maintained sum in O(1) time

Code -

solution.c — C

typedef struct {
    int n;
    long long* tree;
    int* lazy;
} SegmentTree;

SegmentTree* createSegmentTree(int* nums, int n) {
    SegmentTree* st = (SegmentTree*)malloc(sizeof(SegmentTree));
    st->n = n;
    st->tree = (long long*)calloc(4 * n, sizeof(long long));
    st->lazy = (int*)calloc(4 * n, sizeof(int));
    
    void build(int* nums, int node, int start, int end) {
        if (start == end) {
            st->tree[node] = nums[start];
        } else {
            int mid = (start + end) / 2;
            build(nums, 2*node+1, start, mid);
            build(nums, 2*node+2, mid+1, end);
            st->tree[node] = st->tree[2*node+1] + st->tree[2*node+2];
        }
    }
    
    build(nums, 0, 0, n - 1);
    return st;
}

void push(SegmentTree* st, int node, int start, int end) {
    if (st->lazy[node] % 2 == 1) {
        st->tree[node] = (end - start + 1) - st->tree[node];
        if (start != end) {
            st->lazy[2*node+1] += st->lazy[node];
            st->lazy[2*node+2] += st->lazy[node];
        }
    }
    st->lazy[node] = 0;
}

void updateRange(SegmentTree* st, int node, int start, int end, int l, int r) {
    push(st, node, start, end);
    if (start > r || end < l) return;
    if (start >= l && end <= r) {
        st->lazy[node]++;
        push(st, node, start, end);
        return;
    }
    int mid = (start + end) / 2;
    updateRange(st, 2*node+1, start, mid, l, r);
    updateRange(st, 2*node+2, mid+1, end, l, r);
    push(st, 2*node+1, start, mid);
    push(st, 2*node+2, mid+1, end);
    st->tree[node] = st->tree[2*node+1] + st->tree[2*node+2];
}

long long getSum(SegmentTree* st) {
    push(st, 0, 0, st->n - 1);
    return st->tree[0];
}

long long* handleQuery(int* nums1, int nums1Size, int* nums2, int nums2Size, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    SegmentTree* st = createSegmentTree(nums1, nums1Size);
    long long nums2Sum = 0;
    for (int i = 0; i < nums2Size; i++) {
        nums2Sum += nums2[i];
    }
    
    long long* result = (long long*)malloc(queriesSize * sizeof(long long));
    *returnSize = 0;
    
    for (int q = 0; q < queriesSize; q++) {
        if (queries[q][0] == 1) {
            int l = queries[q][1], r = queries[q][2];
            updateRange(st, 0, 0, nums1Size - 1, l, r);
        } else if (queries[q][0] == 2) {
            int p = queries[q][1];
            long long onesCount = getSum(st);
            nums2Sum += onesCount * p;
        } else {
            result[(*returnSize)++] = nums2Sum;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * log n)

Each query takes O(log n) time with segment tree operations

⚡ Linearithmic

Space Complexity

O(n)

Segment tree requires O(n) space for internal nodes

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

890 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

Segment Tree with Lazy Propagation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler