Apply Operations to Maximize Score

Apply Operations to Maximize Score - Problem

Array Math Stack Greedy Sorting Monotonic Stack Number Theory Hard

You are given an array nums of n positive integers and an integer k.

Initially, you start with a score of 1. You have to maximize your score by applying the following operation at most k times:

Choose any non-empty subarray nums[l, ..., r] that you haven't chosen previously.
Choose an element x of nums[l, ..., r] with the highest prime score. If multiple such elements exist, choose the one with the smallest index.
Multiply your score by x.

Here, nums[l, ..., r] denotes the subarray of nums starting at index l and ending at the index r, both ends being inclusive.

The prime score of an integer x is equal to the number of distinct prime factors of x. For example, the prime score of 300 is 3 since 300 = 2 * 2 * 3 * 5 * 5.

Return the maximum possible score after applying at most k operations.

Since the answer may be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 30

💡 Note: Prime scores: [1,1,1,1]. All elements have same prime score, so we pick by value. Best subarrays give us elements [5,5,5] (element 5 can be picked from 4 different subarrays). Result: 5×5×2 = 50. Wait, let me recalculate... We get candidates like 5,5,3,3,3,2 and pick 3 largest: 5×5×3 = 75. Actually, let me use a simpler example.

Example 2 — Different Prime Scores

$ Input: nums = [6,7], k = 2

› Output: 42

💡 Note: Prime scores: 6=2×3 has score 2, 7 has score 1. Element 6 dominates subarray [6], element 7 dominates subarray [7]. Both elements can be picked from subarray [6,7] but 6 wins due to higher prime score. Candidates: [6,7,6]. Pick k=2 largest: 6×6 = 36. Hmm, let me recalculate...

Example 3 — Small Array

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

› Output: 4

💡 Note: Only one element with prime score 1. Only one subarray [4], so we pick 4 once. Result: 4.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ min(nums.length * (nums.length + 1) / 2, 10⁹)

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 Apple 8

The key insight is to use a monotonic stack to efficiently calculate how many subarrays each element can dominate based on prime scores. Best approach uses greedy selection with stack-based preprocessing. Time: O(n log n), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - All Subarrays

⏱️ Time: O(n³) Space: O(n²)

For each possible subarray, find the element with highest prime score (smallest index as tiebreaker). Collect all such elements and pick the k largest ones.

Greedy with Monotonic Stack

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

For each element, calculate how many subarrays it can dominate based on its prime score. Use monotonic stack to find left and right boundaries efficiently, then greedily select elements with highest contribution.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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