# Solving Leetcode Interviews in Seconds with AI: Beautiful Towers I


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2865" 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 an array heights of n integers representing the number of bricks in n consecutive towers. Your task is to remove some bricks to form a mountain-shaped tower arrangement. In this arrangement, the tower heights are non-decreasing, reaching a maximum peak value with one or multiple consecutive towers and then non-increasing. Return the maximum possible sum of heights of a mountain-shaped tower arrangement.   Example 1:  Input: heights = [5,3,4,1,1] Output: 13 Explanation: We remove some bricks to make heights = [5,3,3,1,1], the peak is at index 0.  Example 2:  Input: heights = [6,5,3,9,2,7] Output: 22 Explanation: We remove some bricks to make heights = [3,3,3,9,2,2], the peak is at index 3.  Example 3:  Input: heights = [3,2,5,5,2,3] Output: 18 Explanation: We remove some bricks to make heights = [2,2,5,5,2,2], the peak is at index 2 or 3.    Constraints:  1 <= n == heights.length <= 103 1 <= heights[i] <= 109  

	# Explanation
	Here's the breakdown of the approach, complexities, and the Python code:

*   **High-Level Approach:**
    *   Calculate the longest non-decreasing subsequence sum from the left for each index `i`.
    *   Calculate the longest non-decreasing subsequence sum from the right for each index `i`.
    *   Iterate through each index `i` as a potential peak and compute the mountain sum by taking the minimum of the left and right sums at each position up to that peak index, and from that peak index up to the end. Sum these mins, and find the maximum among all potential peak positions.

*   **Complexity:**
    *   Runtime: O(n<sup>2</sup>), due to the nested loops in calculating the longest non-decreasing subsequences from both sides.
    *   Storage: O(n), for storing the left and right subsequence sums.

*   **Python Code:**

	
	# Code
	```python
	def max_mountain_sum(heights):    n = len(heights)
    left_sums = [0] * n
    right_sums = [0] * n

    for i in range(n):
        left_sums[i] = heights[i]
        for j in range(i):
            if heights[i] >= heights[j]:
                left_sums[i] = max(left_sums[i], left_sums[j] + heights[i])

    for i in range(n - 1, -1, -1):
        right_sums[i] = heights[i]
        for j in range(i + 1, n):
            if heights[i] >= heights[j]:
                right_sums[i] = max(right_sums[i], right_sums[j] + heights[i])

    max_sum = 0
    for i in range(n):
        current_sum = 0
        for j in range(i + 1):
            current_sum += min(heights[j], \
                                (left_sums[j] - sum([heights[k] for k in range(j)] if j > 0 else [0])) if left_sums[j] != 0 else heights[j], \
                                (right_sums[j] - sum([heights[k] for k in range(j)] if j > 0 else [0])) if right_sums[j] != 0 else heights[j])

        for j in range(i + 1, n):
            current_sum += min(heights[j], \
                                (left_sums[j] - sum([heights[k] for k in range(j)] if j > 0 else [0])) if left_sums[j] != 0 else heights[j], \
                                (right_sums[j] - sum([heights[k] for k in range(j)] if j > 0 else [0])) if right_sums[j] != 0 else heights[j])

        max_sum = max(max_sum, sum([min((left_sums[k] - sum([heights[x] for x in range(k)] if k > 0 else [0])) if left_sums[k] != 0 else heights[k], (right_sums[k] - sum([heights[x] for x in range(k)] if k > 0 else [0])) if right_sums[k] != 0 else heights[k]) for k in range(n) if (left_sums[k] - sum([heights[x] for x in range(k)] if k > 0 else [0])) if left_sums[k] != 0 else heights[k] != 0 or (right_sums[k] - sum([heights[x] for x in range(k)] if k > 0 else [0])) if right_sums[k] != 0 else heights[k] != 0]))

    max_mountain_sum = 0
    for i in range(n):
      current_mountain_sum = 0
      left_min = [0] * n
      right_min = [0] * n

      left_min[0] = heights[0]
      for j in range(1, i+1):
        left_min[j] = min(heights[j], left_min[j-1])

      right_min[n-1] = heights[n-1]
      for j in range(n-2, i-1, -1):
        right_min[j] = min(heights[j], right_min[j+1])

      for j in range(i+1):
        current_mountain_sum += left_min[j]

      for j in range(i+1, n):
        current_mountain_sum += right_min[j]

      max_mountain_sum = max(max_mountain_sum, current_mountain_sum)

    return max_mountain_sum
	```