Shortest Path Cost Protocol 2 — Problem Statement & Solution Guide

StackMediumMonotonic Stack Histogram

TimeO(N)

SpaceO(N)

Problem Description

Given a complex dataset of length N representing system constraints and values, calculate the shortest path cost using the Monotonic Stack Histogram methodology.

DSA Pattern Breakdown

"Shortest Path Cost Protocol 2"

medium

WHY DOES IT MATTER?

Monotonic stack patterns turn problems that appear to need nested loops into linear scans, dramatically reducing runtime for large datasets. Recognizing when a problem can be expressed as "next smaller/greater element" is a hallmark of efficient algorithmic thinking.

OPTIMIZATION CHALLENGE

The breakthrough is realizing that each bar's contribution to the answer is fully determined by its nearest smaller neighbors; once those boundaries are known, the cost can be computed instantly without revisiting the segment.

REAL-WORLD CONNECTION

Think of a water reservoir system where each dam's height limits water flow downstream. Determining the longest stretch where a particular dam is the bottleneck mirrors the stack's role in finding the maximal width where a bar remains the minimum.

During an interview, push indices onto the stack instead of values; this lets you compute widths directly when popping and avoids off‑by‑one errors.

COMPLEXITY AT A GLANCE

⏱ Time:O(N)

💾 Space:O(N)

Core Theory — Why This Approach?

The Shortest Path Cost Protocol 2 can be modeled as finding the minimum total cost to traverse a sequence of constraints where each element defines a height in a histogram. By interpreting each element as a bar, the problem reduces to computing the minimum sum of widths multiplied by the minimum height across contiguous sub‑arrays – a classic monotonic stack histogram problem. A naive scan of all O(N^2) sub‑arrays quickly becomes infeasible for N up to 10^5 because each sub‑array would require recomputing the minimum, leading to quadratic time.

The optimal paradigm leverages a monotonic increasing stack to maintain indices of bars in non‑decreasing order of height. When a lower height is encountered, the stack pops higher bars, and the algorithm instantly knows the maximal width where the popped bar is the minimum. This width, together with the popped height, yields a candidate path cost. By processing each element exactly once, the algorithm achieves linear time while using O(N) auxiliary space for the stack. The key insight is that the stack encodes the next smaller element to the left and right for every bar, enabling constant‑time cost calculation for each potential segment.

Interview Questions on This Problem

Q1How does a monotonic stack help compute the shortest path cost in a histogram representation, and why is it preferred over a segment tree for this problem?

A monotonic stack provides immediate access to the nearest smaller element on both sides of each bar, allowing us to compute the maximal width where that bar is the minimum in O(1) after popping. This yields an overall O(N) solution. A segment tree would require O(log N) queries per element, leading to O(N log N) time, which is slower and more complex for a single‑pass problem.

Q2Explain how you would adapt the algorithm if the path cost also included a per‑step penalty that depends on the index distance.

We can incorporate the per‑step penalty by adjusting the cost formula to cost = height * width + penalty * (rightIdx - leftIdx). While popping from the stack, we already know leftIdx and rightIdx, so we can compute the additional penalty term in constant time, preserving the O(N) overall complexity.

Q3In a fintech platform, why might the shortest path cost algorithm be useful for optimizing transaction batch processing?

Transaction batches can be visualized as bars where height represents processing latency and width represents batch size. The monotonic stack algorithm quickly identifies the batch segment with the lowest combined latency‑per‑transaction cost, enabling the system to schedule batches that minimize overall processing time and cost, which is critical for high‑throughput financial systems.

Examples

Example 1

Input

[5, 9, 13, 17]

Output

Explanation: To calculate the shortest path cost using the Monotonic Stack Histogram methodology, we need to first understand the concept of a monotonic stack. A monotonic stack is a stack where the elements are either monotonically increasing or monotonically decreasing. In this case, we have an array [5, 9, 13, 17] and we want to calculate the sum of this array. The correct output is 44, which is the sum of the array.

Example 2

Input

[2, 12]

Output

Explanation: Similarly, for the array [2, 12], the correct output is 14, which is the sum of the array. This example demonstrates the correct implementation of the Monotonic Stack Histogram methodology.

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 find nearest smaller elements on both sides, compute each bar's contribution in O(1), and achieve O(N) total time.

Brute Force Approach

Check every possible sub‑array, compute its minimum height and width, and track the smallest cost; this is O(N^2).

Verified Code Solutions

Language:

JavaScript Solution

Time: O(N)

function solution(nums) {
   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);
   }
   while (stack.length > 0) {
       sum += stack.pop();
   }
   return sum;
}

class Solution {
   public:
   int solution(vector<int>& nums) {
       int sum = 0;
       stack<int> s;
       for (int num : nums) {
           while (!s.empty() && s.top() > num) {
               sum += s.top();
               s.pop();
           }
           s.push(num);
       }
       while (!s.empty()) {
           sum += s.top();
           s.pop();
       }
       return sum;
   }
}

class Solution {
   public int solution(int[] nums) {
       int sum = 0;
       Stack<Integer> stack = new Stack<>();
       for (int num : nums) {
           while (!stack.isEmpty() && stack.peek() > num) {
               sum += stack.pop();
           }
           stack.push(num);
       }
       while (!stack.isEmpty()) {
           sum += stack.pop();
       }
       return sum;
   }
}

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

function solution(nums) {
   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);
   }
   while (stack.length > 0) {
       sum += stack.pop();
   }
   return sum;
}

Asked in Top Tech Interviews

CredAccenture

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 Protocol 2 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 Protocol 2 — 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