Introduction

In this blog post, we will explore how to solve the LeetCode problem "2281" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

As the ruler of a kingdom, you have an army of wizards at your command. You are given a 0-indexed integer array strength, where strength[i] denotes the strength of the ith wizard. For a contiguous group of wizards (i.e. the wizards' strengths form a subarray of strength), the total strength is defined as the product of the following two values: The strength of the weakest wizard in the group. The total of all the individual strengths of the wizards in the group. Return the sum of the total strengths of all contiguous groups of wizards. Since the answer may be very large, return it modulo 109 + 7. A subarray is a contiguous non-empty sequence of elements within an array. Example 1: Input: strength = [1,3,1,2] Output: 44 Explanation: The following are all the contiguous groups of wizards: - [1] from [1,3,1,2] has a total strength of min([1]) sum([1]) = 1 1 = 1 - [3] from [1,3,1,2] has a total strength of min([3]) sum([3]) = 3 3 = 9 - [1] from [1,3,1,2] has a total strength of min([1]) sum([1]) = 1 1 = 1 - [2] from [1,3,1,2] has a total strength of min([2]) sum([2]) = 2 2 = 4 - [1,3] from [1,3,1,2] has a total strength of min([1,3]) sum([1,3]) = 1 4 = 4 - [3,1] from [1,3,1,2] has a total strength of min([3,1]) sum([3,1]) = 1 4 = 4 - [1,2] from [1,3,1,2] has a total strength of min([1,2]) sum([1,2]) = 1 3 = 3 - [1,3,1] from [1,3,1,2] has a total strength of min([1,3,1]) sum([1,3,1]) = 1 5 = 5 - [3,1,2] from [1,3,1,2] has a total strength of min([3,1,2]) sum([3,1,2]) = 1 6 = 6 - [1,3,1,2] from [1,3,1,2] has a total strength of min([1,3,1,2]) sum([1,3,1,2]) = 1 7 = 7 The sum of all the total strengths is 1 + 9 + 1 + 4 + 4 + 4 + 3 + 5 + 6 + 7 = 44. Example 2: Input: strength = [5,4,6] Output: 213 Explanation: The following are all the contiguous groups of wizards: - [5] from [5,4,6] has a total strength of min([5]) sum([5]) = 5 5 = 25 - [4] from [5,4,6] has a total strength of min([4]) sum([4]) = 4 4 = 16 - [6] from [5,4,6] has a total strength of min([6]) sum([6]) = 6 6 = 36 - [5,4] from [5,4,6] has a total strength of min([5,4]) sum([5,4]) = 4 9 = 36 - [4,6] from [5,4,6] has a total strength of min([4,6]) sum([4,6]) = 4 10 = 40 - [5,4,6] from [5,4,6] has a total strength of min([5,4,6]) sum([5,4,6]) = 4 15 = 60 The sum of all the total strengths is 25 + 16 + 36 + 36 + 40 + 60 = 213. Constraints: 1 <= strength.length <= 105 1 <= strength[i] <= 109

Explanation

Here's the solution to the problem:

• Key Idea: The core idea is to efficiently calculate the sum of total strengths for all subarrays. To avoid redundant calculations, we precompute prefix sums and prefix sums of prefix sums. We use the concept of Nearest Smaller Element (NSE) to identify the range for which each element is the minimum. This is done to avoid recalculating minimums for every subarray.
• Optimization: Using prefix sums for efficient calculation of subarray sums and using stack data structure for efficient computation of Nearest Smaller Elements(NSE) to the left and right, making algorithm much faster by skipping unnecessary iterations.

• Modulo Arithmetic: Keep taking modulo at each step to avoid integer overflow issues.

• Complexity:

  • Runtime: O(n)
  • Storage: O(n)

Code

    def totalStrength(strength):
    n = len(strength)
    MOD = 10**9 + 7

    # Calculate prefix sums
    prefix_sum = [0] * (n + 1)
    for i in range(n):
        prefix_sum[i + 1] = (prefix_sum[i] + strength[i]) % MOD

    # Calculate prefix sums of prefix sums
    prefix_sum_sum = [0] * (n + 2)
    for i in range(1, n + 1):
        prefix_sum_sum[i + 1] = (prefix_sum_sum[i] + prefix_sum[i]) % MOD

    # Find left and right boundaries for each element
    left = [0] * n
    right = [0] * n
    stack = []

    for i in range(n):
        while stack and strength[stack[-1]] > strength[i]:
            stack.pop()
        if stack:
            left[i] = stack[-1] + 1
        else:
            left[i] = 0
        stack.append(i)

    stack = []
    for i in range(n - 1, -1, -1):
        while stack and strength[stack[-1]] >= strength[i]:
            stack.pop()
        if stack:
            right[i] = stack[-1] - 1
        else:
            right[i] = n - 1
        stack.append(i)

    # Calculate total strength
    total = 0
    for i in range(n):
        l = left[i]
        r = right[i]

        sum_right = (prefix_sum_sum[r + 2] - prefix_sum_sum[i + 1]) % MOD
        sum_left = (prefix_sum_sum[i + 1] - prefix_sum_sum[l]) % MOD

        len_right = r - i
        len_left = i - l + 1

        total += strength[i] * (sum_right * len_left - sum_left * len_right)
        total %= MOD

    return total