Minimum Total Distance Traveled - Practice Coding Problems

Minimum Total Distance Traveled - Problem

Imagine you're managing a fleet of broken robots scattered across a long assembly line (represented as the X-axis). These robots need to be repaired at specific repair factories positioned at various points along the line.

Here's the challenge: Each robot can move in either direction along the X-axis, but once you set their initial direction, they move at constant speed until they reach a factory that can repair them. Each factory has a limited capacity - it can only repair a certain number of robots before it's full.

Your goal is to strategically set the initial movement direction for each robot to minimize the total distance traveled by all robots combined.

Key Details:

Robots never collide - they either move in parallel or pass through each other
A robot will stop at the first available factory it reaches (that hasn't reached capacity)
You have full control over each robot's initial direction
All robots are guaranteed to eventually find a factory

Input: An array robot[] with robot positions, and a 2D array factory[] where each element is [position, capacity]

Output: The minimum total distance that needs to be traveled by all robots

Input & Output

example_1.py — Basic Case

$ Input: robot = [0,4,6], factory = [[2,2],[6,2]]

› Output: 4

💡 Note: Robot at position 0 goes to factory at position 2 (distance=2). Robot at position 4 goes to factory at position 2 (distance=2). Robot at position 6 goes to factory at position 6 (distance=0). Total distance = 2+2+0 = 4.

example_2.py — Multiple Factories

$ Input: robot = [1,-1], factory = [[-2,1],[2,1]]

› Output: 2

💡 Note: Robot at position 1 goes to factory at position 2 (distance=1). Robot at position -1 goes to factory at position -2 (distance=1). Total distance = 1+1 = 2.

example_3.py — Capacity Constraint

$ Input: robot = [9,11,99,101], factory = [[10,1],[7,1],[14,1],[100,1],[96,1],[103,1]]

› Output: 6

💡 Note: Optimal assignment: robot 9→factory 10 (dist=1), robot 11→factory 7 (dist=4), robot 99→factory 96 (dist=3), robot 101→factory 103 (dist=2). But this violates the constraint that robot 11 can't reach factory 7 if robot 9 goes to factory 10. The actual optimal is robot positions matched to nearest available factories respecting the movement constraint.

Constraints

1 ≤ robot.length, factory.length ≤ 100
-10⁹ ≤ robot[i], factory[j][0] ≤ 10⁹
0 ≤ factory[j][1] ≤ robot.length
All robot positions are unique
All factory positions are unique
Sum of all factory[j][1] ≥ robot.length (all robots can be repaired)

Visualization

Tap to expand

Understanding the Visualization

Assess Situation

Map out patient locations (robots) and hospital locations with bed counts (factories)

Sort by Location

Arrange patients and hospitals by position to minimize crossing paths

Dynamic Assignment

Use DP to optimally decide which patients go to which hospitals

Execute Plan

Dispatch ambulances following the optimal assignment plan

Key Takeaway

🎯 Key Insight: Sort both arrays first, then use DP to make locally optimal decisions that build up to the globally optimal solution. Never assign robots in a way that causes them to cross paths unnecessarily.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses Dynamic Programming with sorted arrays. After sorting robots and factories by position, we expand factories into individual repair slots and use DP to decide for each robot whether to assign it to the current available factory slot or save that slot for a future robot. The key insight is that in an optimal solution, we never need to have robots cross paths - if robot A is to the left of robot B, then robot A should be assigned to a factory that's at or to the left of robot B's factory. Time complexity: O(n × m) where n is robots count and m is total factory capacity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O(n! × m)	O(n + m)	Try every possible assignment of robots to factories
Dynamic Programming (Optimal)	O(n * m * log(n + m))	O(n * m)	Sort both arrays and use DP to optimally assign robots to factories

Brute Force (Try All Assignments) — Algorithm Steps

Expand each factory into individual repair slots based on capacity
Generate all possible assignments of robots to factory slots
For each assignment, calculate total distance traveled
Return the minimum total distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Factories

Convert each factory into individual repair slots based on capacity

Generate Assignments

Try every possible way to assign robots to factory slots

Calculate Distance

For each assignment, sum up travel distances

Find Minimum

Keep track of the assignment with minimum total distance

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long backtrack(int* robot, int robotSize, int* factories, int factorySize, int robotIdx, int* used, long long currentDist) {
    if (robotIdx == robotSize) {
        return currentDist;
    }
    
    long long minDist = LLONG_MAX;
    for (int i = 0; i < factorySize; i++) {
        if (!used[i]) {
            used[i] = 1;
            long long dist = abs(robot[robotIdx] - factories[i]);
            long long total = backtrack(robot, robotSize, factories, factorySize, robotIdx + 1, used, currentDist + dist);
            if (total < minDist) {
                minDist = total;
            }
            used[i] = 0;
        }
    }
    
    return minDist;
}

long long minimumTotalDistance(int* robot, int robotSize, int** factory, int factorySize, int* factoryColSize) {
    qsort(robot, robotSize, sizeof(int), compare);
    
    // Create expanded factory array
    int* factories = malloc(1000 * sizeof(int));
    int factoryCount = 0;
    
    for (int i = 0; i < factorySize; i++) {
        for (int j = 0; j < factory[i][1]; j++) {
            factories[factoryCount++] = factory[i][0];
        }
    }
    
    int* used = calloc(factoryCount, sizeof(int));
    long long result = backtrack(robot, robotSize, factories, factoryCount, 0, used, 0);
    
    free(factories);
    free(used);
    return result;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m)

We try all n! permutations of robot assignments to factory slots, with m factory slots total

⚠ Quadratic Growth

Space Complexity

O(n + m)

Space to store robot and factory arrays, plus recursion stack

⚡ Linearithmic Space

28.9K 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

Brute Force (Try All Assignments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler