# Solving Leetcode Interviews in Seconds with AI: Minimum Sum of Mountain Triplets II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2909" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), 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
	> You are given a 0-indexed array nums of integers. A triplet of indices (i, j, k) is a mountain if:  i < j < k nums[i] < nums[j] and nums[k] < nums[j]  Return the minimum possible sum of a mountain triplet of nums. If no such triplet exists, return -1.   Example 1:  Input: nums = [8,6,1,5,3] Output: 9 Explanation: Triplet (2, 3, 4) is a mountain triplet of sum 9 since:  - 2 < 3 < 4 - nums[2] < nums[3] and nums[4] < nums[3] And the sum of this triplet is nums[2] + nums[3] + nums[4] = 9. It can be shown that there are no mountain triplets with a sum of less than 9.  Example 2:  Input: nums = [5,4,8,7,10,2] Output: 13 Explanation: Triplet (1, 3, 5) is a mountain triplet of sum 13 since:  - 1 < 3 < 5 - nums[1] < nums[3] and nums[5] < nums[3] And the sum of this triplet is nums[1] + nums[3] + nums[5] = 13. It can be shown that there are no mountain triplets with a sum of less than 13.  Example 3:  Input: nums = [6,5,4,3,4,5] Output: -1 Explanation: It can be shown that there are no mountain triplets in nums.    Constraints:  3 <= nums.length <= 105 1 <= nums[i] <= 108  

	# Explanation
	*   **Prefix Minimums and Suffix Minimums:** The core idea is to precompute prefix minimums and suffix minimums. For each element `nums[j]`, we want to quickly find the smallest element to its left (`nums[i]`) and the smallest element to its right (`nums[k]`) such that `i < j < k` and `nums[i] < nums[j]` and `nums[k] < nums[j]`.
*   **Iteration and Comparison:** We iterate through the array (excluding the first and last elements) to consider each element as the potential peak (`nums[j]`) of a mountain.
*   **Finding the Minimum Sum:** For each potential peak, we check if a valid `i` and `k` exist based on precomputed prefix and suffix minimums. If they do, we calculate the sum and update the overall minimum sum.

*   **Runtime Complexity:** O(n), **Storage Complexity:** O(n)

	
	# Code
	```python
	def minimumMountainTriplet(nums):
    n = len(nums)
    prefix_min = [float('inf')] * n
    suffix_min = [float('inf')] * n

    prefix_min[0] = nums[0]
    for i in range(1, n):
        prefix_min[i] = min(prefix_min[i-1], nums[i])

    suffix_min[n-1] = nums[n-1]
    for i in range(n-2, -1, -1):
        suffix_min[i] = min(suffix_min[i+1], nums[i])

    min_sum = float('inf')

    for j in range(1, n - 1):
        if prefix_min[j-1] < nums[j] and suffix_min[j+1] < nums[j]:
            min_sum = min(min_sum, prefix_min[j-1] + nums[j] + suffix_min[j+1])

    if min_sum == float('inf'):
        return -1
    else:
        return min_sum
	```