Merge Operations for Minimum Travel Time - Practice Coding Problems

Merge Operations for Minimum Travel Time - Problem

Imagine you're planning a road trip on a straight highway of length l km. Along this highway, there are n roadside signs at specific positions, with the first sign at position 0 (start) and the last sign at position l (destination).

Here's the twist: each segment between adjacent signs has different travel times per kilometer. The array time[i] tells you how many minutes it takes to travel 1 km between sign i and sign i+1.

You have a special power: you can perform exactly k merge operations. In each merge, you can:

Choose two adjacent signs at positions i and i+1 (where i > 0 and i+1 < n-1)
Combine their travel times: time[i+1] = time[i] + time[i+1]
Remove the sign at position i

Goal: After performing exactly k merges, find the minimum total travel time to go from position 0 to position l.

Think of it as optimally removing road signs to create longer segments with combined travel rates, minimizing your total journey time!

Input & Output

example_1.py — Basic Case

$ Input: l = 10, n = 5, k = 1 position = [0, 2, 5, 7, 10] time = [3, 4, 2, 1]

› Output: 32

💡 Note: With k=1 merge, we can remove one intermediate sign. If we remove sign at position 5, we merge segments with times 4 and 2, giving us segments with times [3, 6, 1] and distances [2, 5, 3]. Total time = 2×3 + 5×6 + 3×1 = 6 + 30 + 3 = 39. The optimal merge gives 32.

example_2.py — Multiple Merges

$ Input: l = 8, n = 4, k = 1 position = [0, 3, 6, 8] time = [2, 3, 1]

› Output: 22

💡 Note: Original segments: distances [3, 3, 2] with times [2, 3, 1]. Total = 3×2 + 3×3 + 2×1 = 6 + 9 + 2 = 17. After merging optimally with k=1, we can get a better arrangement with total time 22.

example_3.py — Edge Case

$ Input: l = 5, n = 3, k = 0 position = [0, 2, 5] time = [4, 2]

› Output: 14

💡 Note: No merges allowed (k=0). Travel time = 2×4 + 3×2 = 8 + 6 = 14. This is the baseline without any optimization.

Constraints

2 ≤ n ≤ 1000
1 ≤ k ≤ n - 2
1 ≤ l ≤ 10⁵
position[0] = 0 and position[n-1] = l
1 ≤ time[i] ≤ 100
position array is strictly increasing

Visualization

Tap to expand

Understanding the Visualization

Original Highway

Start with n toll stations creating n-1 segments, each with different time rates per km

Merge Operations

Remove k intermediate stations, combining their time rates with adjacent segments

Calculate Cost

For each segment, multiply distance by combined time rate to get travel cost

Optimize

Find the combination of k merges that minimizes total travel time

Key Takeaway

🎯 Key Insight: This is an optimal interval partitioning problem where we use dynamic programming to find the best way to merge exactly k segments, minimizing the weighted sum of distances times their combined time rates.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires dynamic programming to find the optimal way to partition the road after exactly k merges. The key insight is that we're looking for the minimum cost interval partitioning where each merge operation combines adjacent segments. The optimal solution uses DP with state dp[i][j] representing minimum cost to reach position i with j merges, achieving O(n³k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³k)	O(nk)	Use DP to find optimal partitioning of the road after k merges
Brute Force (Try All Combinations)	O(C(n,k) * k)	O(n)	Try all possible combinations of k merge operations

Dynamic Programming (Optimal) — Algorithm Steps

Calculate prefix sums for efficient range sum queries
Define DP state: dp[i][j] = min cost to reach position i with j merges
For each position and merge count, try all possible previous positions
Use cost function to calculate segment travel time
Return dp[n-1][k] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Create dp[i][j] = min cost to reach position i with j merges

Fill Base Cases

Set dp[0][0] = 0 (no cost to start at position 0)

Build Solution

For each position and merge count, try all previous positions

Extract Answer

Return dp[n-1][k] as the minimum travel time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

typedef long long ll;

ll segmentCost(int i, int j, int* position, int* time) {
    ll totalTime = 0;
    for (int idx = i; idx < j; idx++) {
        totalTime += time[idx];
    }
    ll distance = position[j] - position[i];
    return distance * totalTime;
}

int minimumTravelTime(int l, int n, int k, int* position, int* time) {
    const ll INF = LLONG_MAX;
    
    // Allocate 2D DP array
    ll** dp = malloc(n * sizeof(ll*));
    for (int i = 0; i < n; i++) {
        dp[i] = malloc((k + 1) * sizeof(ll));
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INF;
        }
    }
    
    dp[0][0] = 0;
    
    for (int merges = 0; merges <= k; merges++) {
        for (int pos = 1; pos < n; pos++) {
            for (int prevPos = 0; prevPos < pos; prevPos++) {
                int segmentsMerged = pos - prevPos - 1;
                if (segmentsMerged <= merges) {
                    int remainingMerges = merges - segmentsMerged;
                    if (dp[prevPos][remainingMerges] != INF) {
                        ll cost = segmentCost(prevPos, pos, position, time);
                        ll newCost = dp[prevPos][remainingMerges] + cost;
                        if (newCost < dp[pos][merges]) {
                            dp[pos][merges] = newCost;
                        }
                    }
                }
            }
        }
    }
    
    ll result = dp[n-1][k];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return (int)result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³k)

Three nested loops: position (n), merges (k), and trying all previous positions (n)

⚠ Quadratic Growth

Space Complexity

O(nk)

2D DP table storing states for each position and merge count

⚡ Linearithmic Space

26.0K Views

Medium Frequency

~35 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler