Beautiful Towers II - Monotonic Increasing Stack [JS]

By on

Description 

Solution: Monotonic Increasing Stack

Find the maximum possible sum of heights ending and starting at each index i.

  • left: left[i] = sum of heights from (0, ..., i) such that they are descending from index i to 0.
  • right: right[i] = sum of heights from (i, ..., n - 1) such that they are descending from index i to n - 1.

Use a monotonic increasing stack to store indices of maxHeights such that they are smaller than maxHeights[i].

  • left to right: We know that from index i to stack[stack.length - 1], all heights are smaller than maxHeights[i].
  • Take the existing sum up to stack[stack.length - 1] (left[stack[stack.length - 1]]) and add the sum for the current range (maxHeights[i] * (i - stack[stack.length - 1]))
  • Then, do the same from right to left.

Take each maxHeights[i] as the peak of the mountain and use the results from left[i] and right[i] to calculate the total sum of heights.

Time Complexity: O(n)
Space Complexity: O(n)

var maximumSumOfHeights = function(maxHeights) {
  let n = maxHeights.length, left = Array(n).fill(0);
  let stack = [];
  for (let i = 0; i < n; i++) {
    while (stack.length && maxHeights[stack[stack.length - 1]] >= maxHeights[i]) stack.pop();
    if (stack.length) {
      let lastIndex = stack[stack.length - 1];
      let currentRange = i - lastIndex;
      left[i] = left[lastIndex] + maxHeights[i] * currentRange;
    } else {
      left[i] = maxHeights[i] * (i + 1);
    }
    stack.push(i);
  }
  stack = [];
  let right = Array(n).fill(0), ans = 0;
  for (let i = n - 1; i >= 0; i--) {
    while (stack.length && maxHeights[stack[stack.length - 1]] >= maxHeights[i]) stack.pop();
    if (stack.length) {
      let lastIndex = stack[stack.length - 1];
      let len = lastIndex - i;
      right[i] = right[lastIndex] + maxHeights[i] * len;
    } else {
      let len = n - i;
      right[i] = maxHeights[i] * len;
    }
    stack.push(i);
    ans = Math.max(ans, left[i] + right[i] - maxHeights[i]);
  }
  return ans;
};
Location: Auckland, New Zealand

Comments

Post a Comment

Popular posts from this blog

Minimum Number of Operations to Sort a Binary Tree by Level - BFS & Cycle Counting Explained [JS]

By on
Description   Solution: BFS & Cycle Counting BFS level-by-level and get minimum swaps for the node values at each level. How to calculate the minimum swaps to sort an array: Get the index of each number in its sorted position (store in a hashmap  indexes ) For each  nums[i] , store the number we need to swap with to place  nums[i]  in its sorted position (store in a hashmap  next ) Find the size of each cycle. Get the total sum of each ( cycle size - 1 ). Why sum of ( cycle size - 1 ) is correct: If cycle size =  1 , we don't need any swaps. If cycle size =  2 , we only need 1 swap. If cycle size =  3 , we need 2 swaps. ---  Main Proof  --- Starting from the smallest number in the cycle, swap each  nums[i]  (where  nums[i]  is in the cycle) into its sorted position. Since the number is now in the correct position, it is no longer in the cycle and this leaves us with a cycle of size ( n - 1 ), where  n = ...
Read more

Reschedule Meetings for Maximum Free Time I - Sliding Window - Constant Space [JS]

By on
Description   Solution: Sliding Window Maintain a sliding window of size  k + 2  and store the running sum of meetings within the window. Within each window, move all meetings as left as possible or right as possible such that there is no space in between the meetings. This maximizes the longest continuous gap. This can be calculated by: last meeting start time - first meeting end time - sum of meeting durations in between first and last meetings. Time Complexity:  O(n) Space Complexity:  O(1) JavaScript function maxFreeTime ( eventTime , k , startTime , endTime ) { const n = startTime . length ; let durationSum = 0 , maxGap = 0 ; for ( let i = 0 ; i < n ; i ++ ) { durationSum += endTime [ i ] - startTime [ i ] ; if ( i >= k ) { durationSum -= endTime [ i - k ] - startTime [ i - k ] ; } if ( i >= k - 1 ) { const lastMeetingStart = i === n - 1 ? eventTime : startTime [ i +...
Read more

Maximum Sum of Distinct Subarrays With Length K - Sliding Window w/ Two Pointers & Set [JS]

By on
Description  Solution: Sliding Window w/ Two Pointers & Set Maintain a sliding window of unique numbers with maximum size of  k . We can store the numbers in the window in a hashset. When we move the right pointer up, move the left pointer up until: all numbers in the window are unique the window size  <= k Time Complexity:  O(n)  246ms Space Complexity:  O(k)  71.5MB var maximumSubarraySum = function ( nums, k ) { let set = new Set (), sum = 0 ; let ans = 0 , n = nums.length; for ( let j = 0 , i = 0 ; j < n; j++) { sum += nums[j]; while (set.has(nums[j]) || j - i >= k) { sum -= nums[i]; set.delete(nums[i]); i++; } set.add(nums[j]); if (j - i + 1 === k) ans = Math .max(ans, sum); } return ans; };
Read more

Count Subarrays With Median K - Count Left & Right Balance [JS]

By on
Description   Solution: Count Left & Right Balance For a subarray to have median of  k : The subarray must contain  k . k  must be the middle element (if odd) or lower mid element (if even). Create subarrays revolving around  nums[i] = k . How do we find whether  k  is the mid/lower mid element? Starting from  k , count the "balance" on the left and right of  k . If  nums[i] < k , add  -1  to the balance. If  nums[i] > k , add  1  to the balance. If  k  is the mid element, the left balance + right balance =  0 . If  k  is the lower mid element, left balance + right balance =  1 . Store the count of left balances in a hashmap. Go through each right balance, Balance = 0 : Count the number of left balances that are equal to ( -right balance ) Balance = 1 : Count the number of left balances that are equal to ( -right balance + 1 ) Time Complexity:  O(n) Space Complexity:...
Read more