Apply Operations to Maximize Score - Practice Coding Problems

Apply Operations to Maximize Score - Problem

Array Math Stack Greedy Sorting Monotonic Stack Number Theory Hard

Apply Operations to Maximize Score

Imagine you're a treasure hunter with a special scoring system! You have an array of positive integers and can perform at most k operations to maximize your score, starting from 1.

🎯 Your Mission:
• Choose any subarray that you haven't used before
• Find the element with the highest prime score (most distinct prime factors)
• If there's a tie, pick the one with the smallest index
• Multiply your current score by this chosen element

📊 Prime Score Explained:
The prime score of a number equals its count of distinct prime factors:
• 300 = 2² × 3 × 5² → Prime score = 3 (factors: 2, 3, 5)
• 12 = 2² × 3 → Prime score = 2 (factors: 2, 3)

Return the maximum possible score modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, 5], k = 2

› Output: 15

💡 Note: Prime scores: 2→1, 3→1, 5→1. All elements have equal prime scores, so we pick by smallest index. We can choose subarrays [5] and [3] to get score 1 × 5 × 3 = 15.

example_2.py — Different Prime Scores

$ Input: nums = [6, 10, 15], k = 2

› Output: 150

💡 Note: Prime scores: 6→2 (2×3), 10→2 (2×5), 15→2 (3×5). All have prime score 2, pick by index. Choose [6] and [10]: 1 × 6 × 10 = 60... Actually, optimal is [15] and [10]: 1 × 15 × 10 = 150.

example_3.py — Single Element

$ Input: nums = [12], k = 1

› Output: 12

💡 Note: Only one element available. Prime score of 12 = 2 (factors: 2, 3). Choose subarray [12], result = 1 × 12 = 12.

Visualization

Tap to expand

Understanding the Visualization

Scout Players

Calculate each player's skill rating (prime score)

Find Territories

Determine which formations each player can dominate

Calculate Impact

Count total formations where each player would be chosen

Draft Strategy

Greedily select highest-value players first

Key Takeaway

🎯 Key Insight: By precomputing each element's contribution range using monotonic stacks, we can transform this complex problem into a simple greedy selection of the highest-value elements!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for monotonic stack computation + O(n log n) for sorting the candidates

⚡ Linearithmic

Space Complexity

O(n)

Space for stacks, prime scores, and candidate list

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ min(nums.length * (nums.length + 1) / 2, 10⁹)
All elements are positive integers
Answer fits in 32-bit integer after modulo

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 24

The optimal solution uses monotonic stacks to efficiently compute the range of subarrays where each element would be the optimal choice, then applies a greedy strategy to select the k operations with maximum value impact. Key insight: precompute contribution ranges in O(n) time, then sort and greedily select in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack + Greedy (Optimal)	O(n log n)	O(n)	Use monotonic stack to find contribution ranges, then greedily select top elements
Brute Force (Check All Subarrays)	O(n² × C(n²,k))	O(n²)	Generate all possible subarrays, find their optimal elements, and try all combinations

Monotonic Stack + Greedy (Optimal) — Algorithm Steps

Compute prime scores for all elements
Use monotonic stacks to find left and right boundaries for each element
Calculate contribution (number of subarrays where each element is optimal)
Create value-contribution pairs and sort by value descending
Greedily select top k operations by picking highest values first

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Prime Scores

Calculate prime factors for each element

Find Left Boundaries

Use monotonic stack to find left extent of dominance

Find Right Boundaries

Use monotonic stack to find right extent of dominance

Calculate Contributions

Multiply left and right ranges to get total subarrays

Greedy Selection

Sort by value and greedily pick top k operations

Code -

solution.c — C

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

#define MOD 1000000007

int getPrimeScore(int x) {
    int factors = 0;
    for (int d = 2; d * d <= x; d++) {
        if (x % d == 0) {
            factors++;
            while (x % d == 0) {
                x /= d;
            }
        }
    }
    if (x > 1) factors++;
    return factors;
}

typedef struct {
    long long value;
    long long contribution;
} Candidate;

int compareDesc(const void* a, const void* b) {
    Candidate* ca = (Candidate*)a;
    Candidate* cb = (Candidate*)b;
    if (ca->value > cb->value) return -1;
    if (ca->value < cb->value) return 1;
    return 0;
}

int maximumScore(int* nums, int numsSize, int k) {
    int* primeScores = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        primeScores[i] = getPrimeScore(nums[i]);
    }
    
    // Find left boundaries
    int* left = (int*)malloc(numsSize * sizeof(int));
    int* stack1 = (int*)malloc(numsSize * sizeof(int));
    int top1 = -1;
    
    for (int i = 0; i < numsSize; i++) {
        left[i] = -1;
        while (top1 >= 0 && 
               (primeScores[stack1[top1]] < primeScores[i] ||
                (primeScores[stack1[top1]] == primeScores[i] && stack1[top1] > i))) {
            top1--;
        }
        if (top1 >= 0) {
            left[i] = stack1[top1];
        }
        stack1[++top1] = i;
    }
    
    // Find right boundaries
    int* right = (int*)malloc(numsSize * sizeof(int));
    int* stack2 = (int*)malloc(numsSize * sizeof(int));
    int top2 = -1;
    
    for (int i = numsSize-1; i >= 0; i--) {
        right[i] = numsSize;
        while (top2 >= 0 && 
               (primeScores[stack2[top2]] < primeScores[i] ||
                (primeScores[stack2[top2]] == primeScores[i] && stack2[top2] > i))) {
            top2--;
        }
        if (top2 >= 0) {
            right[i] = stack2[top2];
        }
        stack2[++top2] = i;
    }
    
    // Create and sort candidates
    Candidate* candidates = (Candidate*)malloc(numsSize * sizeof(Candidate));
    for (int i = 0; i < numsSize; i++) {
        long long leftCount = i - left[i];
        long long rightCount = right[i] - i;
        candidates[i].value = nums[i];
        candidates[i].contribution = leftCount * rightCount;
    }
    qsort(candidates, numsSize, sizeof(Candidate), compareDesc);
    
    // Greedily select operations
    long long result = 1;
    int operations = 0;
    
    for (int i = 0; i < numsSize && operations < k; i++) {
        long long take = candidates[i].contribution;
        if (k - operations < take) {
            take = k - operations;
        }
        for (int j = 0; j < take; j++) {
            result = (result * candidates[i].value) % MOD;
        }
        operations += take;
    }
    
    free(primeScores);
    free(left);
    free(right);
    free(stack1);
    free(stack2);
    free(candidates);
    
    return (int)result;
}

int main() {
    int nums[] = {2, 3, 5};
    int k = 2;
    printf("%d\n", maximumScore(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for monotonic stack computation + O(n log n) for sorting the candidates

⚡ Linearithmic

Space Complexity

O(n)

Space for stacks, prime scores, and candidate list

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ min(nums.length * (nums.length + 1) / 2, 10⁹)
All elements are positive integers
Answer fits in 32-bit integer after modulo

28.6K Views

Medium Frequency

~35 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Monotonic Stack + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler