Mark Elements on Array by Performing Queries

Mark Elements on Array by Performing Queries - Problem

You're given an array of positive integers and a series of queries that will mark elements based on specific rules. Your task is to simulate this marking process and track the sum of unmarked elements after each query.

The Process:

Start with all elements unmarked
For each query [index, k]:
- Mark the element at the given index (if not already marked)
- Then mark k additional unmarked elements with the smallest values
- If there are ties in values, prioritize elements with smaller indices
Return the sum of all unmarked elements after each query

Example: Given nums = [1, 2, 2, 1, 2, 3, 1] and query [1, 2], you would mark index 1 (value 2), then mark the 2 smallest unmarked values (the 1's at indices 0 and 3).

Input & Output

example_1.py — Basic Query Processing

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

› Output: [8,3,3]

💡 Note: Initially sum = 16. Query [1,2]: mark index 1 (value 2), then mark 2 smallest: indices 0 and 3 (both value 1). Sum = 16-2-1-1 = 12. Wait, let me recalculate... Actually after marking indices 1,0,3 remaining sum = 2+2+3 = 7. Query [3,1]: index 3 already marked, mark 1 smallest unmarked (index 6, value 1). Sum = 2+2+3 = 7-1 = 6. Query [4,0]: mark index 4 only. Sum = 2+3 = 5.

example_2.py — Tie Breaking by Index

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

› Output: [5]

💡 Note: Mark index 0 (value 3), then mark 1 smallest unmarked element. Two elements have value 2 at indices 1 and 2, choose index 1 (smaller index). Remaining: index 2 (value 2) + index 3 (value 3) = 5.

example_3.py — Not Enough Elements

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

› Output: [0]

💡 Note: Mark index 0 (value 1), then try to mark 5 smallest elements but only 1 remains (index 1). Mark it. All elements marked, sum = 0.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ m ≤ 10⁵
0 ≤ index_i < n
1 ≤ k_i ≤ n
Sum of all elements fits in 64-bit integer

Visualization

Tap to expand

Understanding the Visualization

Setup Priority System

Create a priority queue where books are ordered by popularity (value) and shelf position (index)

Process Query

Mark the book at specified location as checked out

Check Out Popular Books

Extract k most popular (smallest value) unchecked books from the priority queue

Calculate Inventory

Sum up the total value of remaining unchecked books

Key Takeaway

🎯 Key Insight: Using a min-heap transforms an O(n) search for minimum elements into O(log n) extractions, making the algorithm efficient for processing multiple queries with large k values.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses a min-heap (priority queue) to efficiently track and extract the smallest unmarked elements. By maintaining elements sorted by value and index, we can process each query in O(k log n) time instead of the brute force O(k × n) approach. The key insight is leveraging the heap's ability to maintain order automatically while we mark elements.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue (Min-Heap) - Optimal	O(n log n + m * k * log n)	O(n)	Use min-heap to efficiently find smallest unmarked elements in O(log n) time
Brute Force (Linear Search for Minimum)	O(m * n * k)	O(n)	For each query, linearly search for k smallest unmarked elements

Priority Queue (Min-Heap) - Optimal — Algorithm Steps

Create a min-heap with all (value, index) pairs
Maintain a boolean array to track marked elements
For each query, mark the specified index
Pop k smallest unmarked elements from heap
Calculate and return sum of remaining unmarked elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Heap

Create min-heap with all (value, index) pairs

Mark Index

Mark element at specified index

Extract Minimums

Pop k smallest unmarked elements from heap

Calculate Sum

Sum remaining unmarked elements

Code -

solution.c — C

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

typedef struct {
    int value;
    int index;
} Item;

typedef struct {
    Item* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->items = malloc(capacity * sizeof(Item));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(Item* a, Item* b) {
    Item temp = *a;
    *a = *b;
    *b = temp;
}

int compare(Item a, Item b) {
    if (a.value != b.value) return a.value - b.value;
    return a.index - b.index;
}

void heapifyUp(MinHeap* heap, int index) {
    if (index == 0) return;
    int parent = (index - 1) / 2;
    if (compare(heap->items[index], heap->items[parent]) < 0) {
        swap(&heap->items[index], &heap->items[parent]);
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MinHeap* heap, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < heap->size && compare(heap->items[left], heap->items[smallest]) < 0)
        smallest = left;
    if (right < heap->size && compare(heap->items[right], heap->items[smallest]) < 0)
        smallest = right;
    
    if (smallest != index) {
        swap(&heap->items[index], &heap->items[smallest]);
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, Item item) {
    heap->items[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Item pop(MinHeap* heap) {
    Item min = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

long long* solution(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    // Create heap and add all elements
    MinHeap* heap = createHeap(numsSize);
    for (int i = 0; i < numsSize; i++) {
        Item item = {nums[i], i};
        push(heap, item);
    }
    
    bool* marked = calloc(numsSize, sizeof(bool));
    long long* result = malloc(queriesSize * sizeof(long long));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int index = queries[q][0];
        int k = queries[q][1];
        
        // Mark element at specified index
        marked[index] = true;
        
        // Mark k smallest unmarked elements
        Item* temp = malloc(numsSize * sizeof(Item));
        int tempSize = 0;
        int count = 0;
        
        while (heap->size > 0 && count < k) {
            Item curr = pop(heap);
            temp[tempSize++] = curr;
            
            if (!marked[curr.index]) {
                marked[curr.index] = true;
                count++;
            }
        }
        
        // Put back all elements
        for (int i = 0; i < tempSize; i++) {
            push(heap, temp[i]);
        }
        
        // Calculate sum of unmarked elements
        long long total = 0;
        for (int i = 0; i < numsSize; i++) {
            if (!marked[i]) {
                total += nums[i];
            }
        }
        result[q] = total;
        
        free(temp);
    }
    
    free(heap->items);
    free(heap);
    free(marked);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m * k * log n)

O(n log n) to build heap, then O(m * k * log n) for all queries to extract elements

⚡ Linearithmic

Space Complexity

O(n)

Space for heap and boolean array to track marked elements

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Priority Queue (Min-Heap) - Optimal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler