Sync LeetCode submission Runtime - 3609 ms (37.93%), Memory - 45 MB (54.31%)

Author: jimit105

3001-apply-operations-to-maximize-score/README.md

@@ -0,0 +1,49 @@
+<p>You are given an array <code>nums</code> of <code>n</code> positive integers and an integer <code>k</code>.</p>
+
+<p>Initially, you start with a score of <code>1</code>. You have to maximize your score by applying the following operation at most <code>k</code> times:</p>
+
+<ul>
+	<li>Choose any <strong>non-empty</strong> subarray <code>nums[l, ..., r]</code> that you haven&#39;t chosen previously.</li>
+	<li>Choose an element <code>x</code> of <code>nums[l, ..., r]</code> with the highest <strong>prime score</strong>. If multiple such elements exist, choose the one with the smallest index.</li>
+	<li>Multiply your score by <code>x</code>.</li>
+</ul>
+
+<p>Here, <code>nums[l, ..., r]</code> denotes the subarray of <code>nums</code> starting at index <code>l</code> and ending at the index <code>r</code>, both ends being inclusive.</p>
+
+<p>The <strong>prime score</strong> of an integer <code>x</code> is equal to the number of distinct prime factors of <code>x</code>. For example, the prime score of <code>300</code> is <code>3</code> since <code>300 = 2 * 2 * 3 * 5 * 5</code>.</p>
+
+<p>Return <em>the <strong>maximum possible score</strong> after applying at most </em><code>k</code><em> operations</em>.</p>
+
+<p>Since the answer may be large, return it modulo <code>10<sup>9 </sup>+ 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [8,3,9,3,8], k = 2
+<strong>Output:</strong> 81
+<strong>Explanation:</strong> To get a score of 81, we can apply the following operations:
+- Choose subarray nums[2, ..., 2]. nums[2] is the only element in this subarray. Hence, we multiply the score by nums[2]. The score becomes 1 * 9 = 9.
+- Choose subarray nums[2, ..., 3]. Both nums[2] and nums[3] have a prime score of 1, but nums[2] has the smaller index. Hence, we multiply the score by nums[2]. The score becomes 9 * 9 = 81.
+It can be proven that 81 is the highest score one can obtain.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [19,12,14,6,10,18], k = 3
+<strong>Output:</strong> 4788
+<strong>Explanation:</strong> To get a score of 4788, we can apply the following operations: 
+- Choose subarray nums[0, ..., 0]. nums[0] is the only element in this subarray. Hence, we multiply the score by nums[0]. The score becomes 1 * 19 = 19.
+- Choose subarray nums[5, ..., 5]. nums[5] is the only element in this subarray. Hence, we multiply the score by nums[5]. The score becomes 19 * 18 = 342.
+- Choose subarray nums[2, ..., 3]. Both nums[2] and nums[3] have a prime score of 2, but nums[2] has the smaller index. Hence, we multipy the score by nums[2]. The score becomes 342 * 14 = 4788.
+It can be proven that 4788 is the highest score one can obtain.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length == n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= min(n * (n + 1) / 2, 10<sup>9</sup>)</code></li>
+</ul>

3001-apply-operations-to-maximize-score/solution.py

@@ -0,0 +1,102 @@
+# Approach 1: Monotonic Stack & Priority Queue
+
+class Solution:
+    MOD = 10**9 + 7
+
+    def maximumScore(self, nums, k):
+        n = len(nums)
+        prime_scores = [0] * n
+
+        # Calculate the prime score for each number in nums
+        for index in range(n):
+            num = nums[index]
+
+            # Check for prime factors from 2 to sqrt(n)
+            for factor in range(2, int(math.sqrt(num)) + 1):
+                if num % factor == 0:
+                    # Increment prime score for each prime factor
+                    prime_scores[index] += 1
+
+                    # Remove all occurrences of the prime factor from num
+                    while num % factor == 0:
+                        num //= factor
+
+            # If num is still greater than or equal to 2, it's a prime factor
+            if num >= 2:
+                prime_scores[index] += 1
+
+        # Initialize next and previous dominant index arrays
+        next_dominant = [n] * n
+        prev_dominant = [-1] * n
+
+        # Stack to store indices for monotonic decreasing prime score
+        decreasing_prime_score_stack = []
+
+        # Calculate the next and previous dominant indices for each number
+        for index in range(n):
+            # While the stack is not empty and the current prime score is greater than the stack's top
+            while (
+                decreasing_prime_score_stack
+                and prime_scores[decreasing_prime_score_stack[-1]]
+                < prime_scores[index]
+            ):
+                top_index = decreasing_prime_score_stack.pop()
+
+                # Set the next dominant element for the popped index
+                next_dominant[top_index] = index
+
+            # If the stack is not empty, set the previous dominant element for the current index
+            if decreasing_prime_score_stack:
+                prev_dominant[index] = decreasing_prime_score_stack[-1]
+
+            # Push the current index onto the stack
+            decreasing_prime_score_stack.append(index)
+
+        # Calculate the number of subarrays in which each element is dominant
+        num_of_subarrays = [0] * n
+        for index in range(n):
+            num_of_subarrays[index] = (next_dominant[index] - index) * (
+                index - prev_dominant[index]
+            )
+
+        # Priority queue to process elements in decreasing order of their value
+        processing_queue = []
+
+        # Push each number and its index onto the priority queue
+        for index in range(n):
+            heapq.heappush(processing_queue, (-nums[index], index))
+
+        score = 1
+
+        # Helper function to compute the power of a number modulo MOD
+        def _power(base, exponent):
+            res = 1
+
+            # Calculate the exponentiation using binary exponentiation
+            while exponent > 0:
+                # If the exponent is odd, multiply the result by the base
+                if exponent % 2 == 1:
+                    res = (res * base) % self.MOD
+
+                # Square the base and halve the exponent
+                base = (base * base) % self.MOD
+                exponent //= 2
+
+            return res
+
+        # Process elements while there are operations left
+        while k > 0:
+            # Get the element with the maximum value from the queue
+            num, index = heapq.heappop(processing_queue)
+            num = -num  # Negate back to positive
+
+            # Calculate the number of operations to apply on the current element
+            operations = min(k, num_of_subarrays[index])
+
+            # Update the score by raising the element to the power of operations
+            score = (score * _power(num, operations)) % self.MOD
+
+            # Reduce the remaining operations count
+            k -= operations
+
+        return score