Find Score of an Array After Marking All Elements

Find Score of an Array After Marking All Elements - Problem

You're given an array of positive integers, and your mission is to accumulate the highest possible score using a specific marking strategy!

The Algorithm:

Start with score = 0
Find the smallest unmarked element in the array (if there's a tie, pick the one with the smallest index)
Add this element's value to your score
Mark this element AND its immediate neighbors (left and right adjacent elements, if they exist)
Repeat until every element is marked

Your goal is to return the final score after applying this greedy marking algorithm.

Example: For array [2,1,3,4,5,2], you'd first pick 1 (smallest), mark positions 0,1,2, then pick 2 from position 5, and so on.

Input & Output

example_1.py — Basic Array

$ Input: [2,1,3,4,5,2]

› Output: 7

💡 Note: Step 1: Pick 1 (smallest), score=1, mark indices [0,1,2]. Step 2: Pick 2 from index 5 (smallest remaining), score=3, mark indices [4,5]. Step 3: Pick 4 from index 3 (only remaining), score=7. Final score = 7.

example_2.py — Small Array

$ Input: [2,3,5,1,3,2]

› Output: 5

💡 Note: Step 1: Pick 1 (index 3), score=1, mark [2,3,4]. Step 2: Pick 2 (index 0), score=3, mark [0,1]. Step 3: Pick 2 (index 5), score=5, mark [5]. All elements marked, final score = 5.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: Only one element exists. Pick 1, add to score. No neighbors to mark. Final score = 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements are positive integers
Array can contain duplicate values

Visualization

Tap to expand

Understanding the Visualization

Survey Cave

Use a priority system (heap) to know which gem is smallest

Pick Smallest

Extract the smallest gem from your priority list

Seal Adjacent

Mark the gem's location and neighbors as sealed

Repeat Strategy

Continue until all gems are collected or sealed

Key Takeaway

🎯 Key Insight: Using a min-heap eliminates repeated scanning, reducing time from O(n²) to O(n log n) while maintaining the greedy strategy of always picking the smallest available element.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a min-heap (priority queue) to efficiently find the smallest unmarked element in O(log n) time. By storing (value, index) pairs in the heap and using a marking array, we achieve O(n log n) time complexity instead of the naive O(n²) approach. The key insight is that we don't need to repeatedly scan the entire array - the heap maintains the minimum element at the top.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n²)	O(n)	Repeatedly scan the entire array to find the smallest unmarked element
Priority Queue (Min-Heap) - Optimal	O(n log n)	O(n)	Use min-heap to efficiently find smallest unmarked elements

Brute Force (Linear Search) — Algorithm Steps

Initialize score = 0 and a boolean array to track marked elements
While there are unmarked elements:
- Scan entire array to find smallest unmarked element
- Add its value to score
- Mark the element and its adjacent neighbors
Return the final score

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with unmarked array [2,1,3,4,5,2]

Find Minimum

Scan entire array, find 1 at index 1

Mark Elements

Add 1 to score, mark indices 0,1,2

Repeat Process

Continue until all elements are marked

Code -

solution.c — C

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

long long findScore(int* nums, int n) {
    bool* marked = (bool*)calloc(n, sizeof(bool));
    long long score = 0;
    
    while (true) {
        int minVal = INT_MAX;
        int minIdx = -1;
        
        // Find smallest unmarked element
        for (int i = 0; i < n; i++) {
            if (!marked[i] && nums[i] < minVal) {
                minVal = nums[i];
                minIdx = i;
            }
        }
        
        // All elements are marked
        if (minIdx == -1) break;
        
        // Add to score and mark element + neighbors
        score += nums[minIdx];
        int start = (minIdx - 1 < 0) ? 0 : minIdx - 1;
        int end = (minIdx + 2 > n) ? n : minIdx + 2;
        for (int j = start; j < end; j++) {
            marked[j] = true;
        }
    }
    
    free(marked);
    return score;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%lld\n", findScore(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We potentially scan the entire array n times to find the minimum unmarked element

⚠ Quadratic Growth

Space Complexity

O(n)

Need additional boolean array to track marked elements

⚡ Linearithmic Space

28.5K Views

High Frequency

~25 min Avg. Time

1.3K 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 (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler