Maximal Score After Applying K Operations

Maximal Score After Applying K Operations - Problem

You are given a 0-indexed integer array nums and an integer k. You have a starting score of 0.

In one operation:

choose an index i such that 0 <= i < nums.length,
increase your score by nums[i], and
replace nums[i] with ceil(nums[i] / 3).

Return the maximum possible score you can attain after applying exactly k operations.

The ceiling function ceil(val) is the least integer greater than or equal to val.

Input & Output

Example 1 — Basic Case

$ Input: nums = [10,10,10,10,10], k = 5

› Output: 50

💡 Note: Pick index 0: score=10, nums=[4,10,10,10,10]. Pick index 1: score=20, nums=[4,4,10,10,10]. Pick index 2: score=30, nums=[4,4,4,10,10]. Pick index 3: score=40, nums=[4,4,4,4,10]. Pick index 4: score=50, nums=[4,4,4,4,4]. Maximum score is 50.

Example 2 — Single Large Element

$ Input: nums = [1,10,3,3,3], k = 3

› Output: 17

💡 Note: Pick 10: score=10, nums=[1,4,3,3,3]. Pick 4: score=14, nums=[1,2,3,3,3]. Pick any 3: score=17, nums=[1,2,1,3,3]. Best strategy is always pick the largest available.

Example 3 — Small Array

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

› Output: 7

💡 Note: Pick 5: score=5, nums=[2]. Pick 2: score=7, nums=[1]. Only one element, so must pick from it k times.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 2 × 10³

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to always pick the largest available element to maximize the score. The greedy max heap approach efficiently tracks the maximum element in O(log n) time per operation. Time: O(n + k log n), Space: O(n)

Common Approaches

✓ One Pass Hash

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

Brute Force - Try All Combinations

⏱️ Time: O(n^k) Space: O(k)

For each of the k operations, try picking from each possible index, recursively explore all combinations, and keep track of the maximum score achieved.

Greedy with Max Heap

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

Use a max heap to efficiently track the largest element. In each operation, extract the maximum, add it to score, reduce it by ceil(val/3), and reinsert. This greedy approach ensures optimal score.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 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