Maximum Score of a Good Subarray solution and explanation

def maximumScore(nums, k):
    n = len(nums)
    left = right = k
    min_val = nums[k]
    max_score = 0

    while left >= 0 or right < n:
        while left >= 0 and (right == n or nums[left] >= nums[right]):
            min_val = min(min_val, nums[left])
            left -= 1
        while right < n and (left < 0 or nums[right] > nums[left]):
            min_val = min(min_val, nums[right])
            right += 1
        max_score = max(max_score, min_val * (right - left - 1))

    return max_score

#include <vector>
#include <algorithm>
using namespace std;

int maximumScore(vector<int>& nums, int k) {
    int n = nums.size();
    int left = k, right = k;
    int min_val = nums[k];
    int max_score = 0;
    
    while (left >= 0 || right < n) {
        while (left >= 0 && (right == n || nums[left] >= nums[right])) {
            min_val = min(min_val, nums[left--]);
        }
        while (right < n && (left < 0 || nums[right] > nums[left])) {
            min_val = min(min_val, nums[right++]);
        }
        max_score = max(max_score, min_val * (right - left - 1));
    }
    
    return max_score;
}

import java.util.Stack;

public class Solution {
    public int maximumScore(int[] nums, int k) {
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        Stack<Integer> stack = new Stack<>();

        // Find the left bounds
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
                stack.pop();
            }
            left[i] = stack.isEmpty() ? 0 : stack.peek() + 1;
            stack.push(i);
        }

        stack.clear();

        // Find the right bounds
        for (int i = n - 1; i >= 0; i--) {
            while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
                stack.pop();
            }
            right[i] = stack.isEmpty() ? n - 1 : stack.peek() - 1;
            stack.push(i);
        }

        int maxScore = 0;
        for (int i = 0; i < n; i++) {
            if (left[i] <= k && k <= right[i]) {
                maxScore = Math.max(maxScore, nums[i] * (right[i] - left[i] + 1));
            }
        }

        return maxScore;
    }
}

function maximumScore(nums, k) {
  const n = nums.length;
  const left = new Array(n);
  const right = new Array(n);
  const stack = [];

  for (let i = 0; i < n; i++) {
    while (stack.length && nums[stack[stack.length - 1]] >= nums[i]) {
      stack.pop();
    }
    left[i] = stack.length ? stack[stack.length - 1] + 1 : 0;
    stack.push(i);
  }

  stack.length = 0;

  for (let i = n - 1; i >= 0; i--) {
    while (stack.length && nums[stack[stack.length - 1]] >= nums[i]) {
      stack.pop();
    }
    right[i] = stack.length ? stack[stack.length - 1] - 1 : n - 1;
    stack.push(i);
  }

  let maxScore = 0;
  for (let i = 0; i < n; i++) {
    if (left[i] <= k && k <= right[i]) {
      maxScore = Math.max(maxScore, nums[i] * (right[i] - left[i] + 1));
    }
  }

  return maxScore;
}

function maximumScore(nums: number[], k: number): number {
    const n = nums.length;
    const left: number[] = Array(n).fill(-1);
    const right: number[] = Array(n).fill(n);
    const stk: number[] = [];
    for (let i = 0; i < n; ++i) {
        while (stk.length && nums[stk.at(-1)] >= nums[i]) {
            stk.pop();
        }
        if (stk.length) {
            left[i] = stk.at(-1);
        }
        stk.push(i);
    }
    stk.length = 0;
    for (let i = n - 1; ~i; --i) {
        while (stk.length && nums[stk.at(-1)] > nums[i]) {
            stk.pop();
        }
        if (stk.length) {
            right[i] = stk.at(-1);
        }
        stk.push(i);
    }
    let ans = 0;
    for (let i = 0; i < n; ++i) {
        if (left[i] + 1 <= k && k <= right[i] - 1) {
            ans = Math.max(ans, nums[i] * (right[i] - left[i] - 1));
        }
    }
    return ans;
}

func maximumScore(nums []int, k int) (ans int) {
	n := len(nums)
	left := make([]int, n)
	right := make([]int, n)
	for i := range left {
		left[i] = -1
		right[i] = n
	}
	stk := []int{}
	for i, v := range nums {
		for len(stk) > 0 && nums[stk[len(stk)-1]] >= v {
			stk = stk[:len(stk)-1]
		}
		if len(stk) > 0 {
			left[i] = stk[len(stk)-1]
		}
		stk = append(stk, i)
	}
	stk = []int{}
	for i := n - 1; i >= 0; i-- {
		v := nums[i]
		for len(stk) > 0 && nums[stk[len(stk)-1]] > v {
			stk = stk[:len(stk)-1]
		}
		if len(stk) > 0 {
			right[i] = stk[len(stk)-1]
		}
		stk = append(stk, i)
	}
	for i, v := range nums {
		if left[i]+1 <= k && k <= right[i]-1 {
			ans = max(ans, v*(right[i]-left[i]-1))
		}
	}
	return
}