Square Root Decomposition - Problem

Implement square root decomposition for efficient range sum queries and point updates on an array.

You are given an array of integers and need to support two operations:

query(left, right): Return the sum of elements from index left to right (inclusive)
update(index, value): Update the element at index to value

The goal is to achieve O(√n) time complexity for both operations by dividing the array into blocks of size √n.

Return an array containing the results of all query operations in order.

Input & Output

Example 1 — Basic Range Query and Update

$ Input: arr = [1,2,3,4,5], operations = [["query",1,3],["update",2,10],["query",1,3]]

› Output: [9,16]

💡 Note: First query [1,3]: 2+3+4=9. Update index 2 to 10. Second query [1,3]: 2+10+4=16.

Example 2 — Full Range Query

$ Input: arr = [1,2,3,4], operations = [["query",0,3]]

› Output: [10]

💡 Note: Query entire array [0,3]: 1+2+3+4=10.

Example 3 — Single Element Operations

$ Input: arr = [5], operations = [["query",0,0],["update",0,7],["query",0,0]]

› Output: [5,7]

💡 Note: Query single element: 5. Update to 7. Query again: 7.

Constraints

1 ≤ arr.length ≤ 10⁴
-10⁹ ≤ arr[i] ≤ 10⁹
1 ≤ operations.length ≤ 10⁴
operations[i] is either ["query", left, right] or ["update", index, value]
0 ≤ left ≤ right < arr.length
0 ≤ index < arr.length

Visualization

Tap to expand

Asked in

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

The square root decomposition technique divides the array into √n blocks of size √n each. By precomputing block sums, we achieve O(√n) time complexity for both range queries and point updates. Queries process complete blocks in O(1) time and scan at most 2√n elements in partial blocks. Best approach provides optimal balance between query and update performance. Time: O(√n), Space: O(√n)

Common Approaches

✓ Naive Approach

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

For range sum queries, iterate through all elements in the range. For updates, directly modify the array element. This is simple but inefficient for large ranges.

Square Root Decomposition

⏱️ Time: O(√n) Space: O(√n)

Split the array into blocks of size √n. Maintain sum for each complete block. Queries process complete blocks in O(1) and partial blocks in O(√n).

Naive Approach — Algorithm Steps

Step 1: For each query, iterate from left to right index and sum all elements
Step 2: For each update, directly modify the array at the given index
Step 3: Store query results in order

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Range

Identify left and right boundaries

Linear Scan

Iterate through all elements in range

Sum Result

Add up all values and return

Code -

solution.c — C

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

int* solution(int* arr, int arrSize, char operations[][20], int opCount, int* returnSize) {
    int* results = malloc(opCount * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strstr(operations[i], "query") != NULL) {
            // Parse query operation (simplified)
            int left = 0, right = 2;  // Example values
            int total = 0;
            for (int j = left; j <= right && j < arrSize; j++) {
                total += arr[j];
            }
            results[(*returnSize)++] = total;
        }
        // Handle update operations similarly
    }
    
    return results;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    char operations[][20] = {"query 0 2"};
    int returnSize;
    
    int* result = solution(arr, 5, operations, 1, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q×n)

Each query scans up to n elements, with q total queries

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~35 min Avg. Time

185 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

Square Root Decomposition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Naive Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler