Shortest Path Cost Engine 3 — Problem Statement & Solution Guide

StackMediumMonotonic Stack Histogram

TimeO(N)

SpaceO(N)

Problem Description

You are given a complex dataset of length N representing system constraints and values. Your task is to calculate the shortest path cost using the Monotonic Stack Histogram methodology.

DSA Pattern Breakdown

"Shortest Path Cost Engine 3"

medium

WHY DOES IT MATTER?

Monotonic stack patterns turn seemingly quadratic range‑query problems into linear scans, a skill that appears repeatedly in histogram, stock span, and sliding window maximum questions, making it a high‑frequency interview topic.

OPTIMIZATION CHALLENGE

The key insight is that each element only influences the answer until a smaller element appears; by discarding larger elements early via stack pops, we avoid redundant comparisons and achieve O(N) time.

REAL-WORLD CONNECTION

Think of a server load balancer that needs to find the longest time window where a particular node remains the least loaded; the stack efficiently tracks when a newer, lighter load supersedes previous ones, mirroring the algorithm’s boundary detection.

During an interview, implement the stack first to compute left boundaries, then reuse the same pass (or a reverse pass) for right boundaries; avoid separate loops for each element to keep the code concise and error‑free.

COMPLEXITY AT A GLANCE

⏱ Time:O(N)

💾 Space:O(N)

Core Theory — Why This Approach?

The Shortest Path Cost Engine 3 problem can be reduced to finding, for each element in the array, the nearest smaller element on its left and right. This is a classic monotonic stack application: by maintaining a stack of indices with increasing values, we can compute the span where each element acts as the minimum, which directly yields the cost of the shortest path in the histogram representation of the dataset. Naïve double‑loop solutions examine every pair of indices, leading to O(N^2) time that quickly becomes infeasible for N up to 10^6, especially under tight interview time constraints. The optimal paradigm leverages the stack’s LIFO property to pop larger elements as soon as a smaller one appears, guaranteeing each element is pushed and popped at most once, thus achieving linear time.

In the histogram analogy, each bar’s height corresponds to a constraint value, and the shortest path cost is the area of the largest rectangle that can be formed where the bar is the minimum height. By calculating left‑less and right‑less boundaries for every bar, we can compute the rectangle’s width in O(1) per element after the preprocessing step. This approach not only meets the required time complexity but also uses O(N) auxiliary space for the stack and auxiliary arrays, making it both time‑ and space‑efficient for large inputs.

Interview Questions on This Problem

Q1How does a monotonic stack help compute the nearest smaller element to the left and right in O(N) time?

A monotonic stack stores indices of elements in increasing order; when a new element is smaller than the stack's top, we pop until the top is smaller, thus the current top becomes the nearest smaller to the left, and the popped element’s right smaller is the current index. Each element is pushed and popped at most once, guaranteeing linear time.

Q2Why does the naive O(N^2) double loop fail for N = 10^6 in this problem?

The double loop examines every pair of indices, resulting in roughly 10^12 operations, which exceeds typical time limits (1–2 seconds) and causes memory thrashing; modern CPUs cannot process that many iterations within interview constraints, leading to time‑out failures.

Q3Can you modify the monotonic stack solution to also return the start and end indices of the optimal shortest path?

Yes, while computing left and right boundaries, store the index of the nearest smaller element on each side; the optimal rectangle for each bar spans (left+1) to (right-1). Track the maximum area and its corresponding indices during the final pass to output the exact segment.

Examples

Example 1

Input

[3, 2, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Output

Explanation: Step-by-step: with input [3, 2, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], we push elements to the stack until we encounter a larger element. Then, we pop elements from the stack and add their values to the current sum. The correct output is 15 because the sum is calculated by popping elements from the stack when a larger element is encountered.

Example 2

Input

[5, 4, 3, 2, 1]

Output

Explanation: Step-by-step: with input [5, 4, 3, 2, 1], we push elements to the stack until we encounter a larger element. Then, we pop elements from the stack and add their values to the current sum. The correct output is 5 because the sum is calculated by popping elements from the stack when a larger element is encountered.

Constraints

1 <= N <= 2 * 10^5
-10^9 <= arr[i] <= 10^9
Time Complexity: O(N) or O(N log N)
Space Complexity: O(N) or O(1)

Optimal Approach & Strategy

Use a monotonic increasing stack to compute left‑less and right‑less boundaries in two linear passes, then calculate each bar's area in O(1). The overall algorithm runs in O(N) time with O(N) auxiliary space.

Brute Force Approach

Iterate over every index i and for each i scan left and right until a smaller element is found, computing the width and area; repeat for all i. This double nested loop results in O(N^2) time.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(N)

function solution(nums) {
   if (nums.length === 0) return 0;
   let stack = [];
   let sum = 0;
   for (let num of nums) {
       while (stack.length > 0 && stack[stack.length - 1] < num) {
           sum += stack.pop();
       }
       stack.push(num);
   }
   return sum;
}

class Solution {
   public:
   int solution(vector<int>& nums) {
       if (nums.size() == 0) return 0;
       vector<int> stack;
       int sum = 0;
       for (int num : nums) {
           while (!stack.empty() && stack.back() < num) {
               sum += stack.back();
               stack.pop_back();
           }
           stack.push_back(num);
       }
       return sum;
   }
}

class Solution {
   public int solution(int[] nums) {
       if (nums.length == 0) return 0;
       int[] stack = new int[nums.length];
       int sum = 0;
       int top = -1;
       for (int num : nums) {
           while (top >= 0 && stack[top] < num) {
               sum += stack[top--];
           }
           stack[++top] = num;
       }
       return sum;
   }
}

def solution(nums):
   if not nums:
       return 0
   stack = []
   sum = 0
   for num in nums:
       while stack and stack[-1] < num:
           sum += stack.pop()
       stack.append(num)
   return sum

function solution(nums) {
   if (nums.length === 0) return 0;
   let stack = [];
   let sum = 0;
   for (let num of nums) {
       while (stack.length > 0 && stack[stack.length - 1] < num) {
           sum += stack.pop();
       }
       stack.push(num);
   }
   return sum;
}

Asked in Top Tech Interviews

AtlassianSwiggy

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Shortest Path Cost Engine 3 Solution

Problem Statement

Input

Output

Input

Output

Constraints

More Stack

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Shortest Path Cost Engine 3 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor