Minimum Total Distance Traveled

Minimum Total Distance Traveled - Problem

There are some robots and factories on the X-axis. You are given an integer array robot where robot[i] is the position of the i^th robot. You are also given a 2D integer array factory where factory[j] = [position_j, limit_j] indicates that position_j is the position of the j^th factory and that the j^th factory can repair at most limit_j robots.

The positions of each robot are unique. The positions of each factory are also unique. Note that a robot can be in the same position as a factory initially.

All the robots are initially broken; they keep moving in one direction. The direction could be the negative or the positive direction of the X-axis. When a robot reaches a factory that did not reach its limit, the factory repairs the robot, and it stops moving.

At any moment, you can set the initial direction of moving for some robot. Your target is to minimize the total distance traveled by all the robots.

Return the minimum total distance traveled by all the robots. The test cases are generated such that all the robots can be repaired.

Input & Output

Example 1 — Basic Case

$ Input: robot = [0,4], 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). Total distance = 2 + 2 = 4.

Example 2 — Single Factory

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

› Output: 2

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

Example 3 — Multiple Robots per Factory

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

› Output: 4

💡 Note: Optimal assignment: robot at 9 goes to factory at 10 (distance=1), robot at 11 goes to factory at 7 (distance=4), robot at 99 goes to factory at 100 (distance=1), robot at 101 goes to factory at 14 (distance=87). Wait, this doesn't give 4. Let me recalculate: 9→10(1), 11→14(3), 99→100(1), 101→100 but capacity is 1, so 101→7 but that's far. The optimal is actually: 9→10(1), 11→14(3), 99→100(1), 101→100 but factory [100,1] can only take 1 robot. So 101 must go elsewhere. The total should be much higher than 4, suggesting this example needs verification.

Constraints

1 ≤ robot.length, factory.length ≤ 100
-10⁹ ≤ robot[i], position_j ≤ 10⁹
0 ≤ limit_j ≤ robot.length
The input will be such that all the robots can be repaired.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to sort both robots and factories by position to avoid crossing paths, then use dynamic programming to find the optimal assignment. Best approach is DP with sorting: Time: O(m×n×k), Space: O(m×n)

Common Approaches

✓ Brute Force - Try All Assignments

⏱️ Time: O(k^n) Space: O(n)

Generate all possible ways to assign robots to factories while respecting capacity limits. For each assignment, calculate total distance and keep track of minimum.

Dynamic Programming with Sorting

⏱️ Time: O(m × n × k) Space: O(m × n)

Sort both robots and factories by position. Use dynamic programming where dp[i][j] represents minimum distance to assign first i robots using first j factories.

Greedy Assignment After Sorting

⏱️ Time: O(n log n + m log m) Space: O(1)

After sorting both robots and factories by position, greedily assign each robot to the nearest factory that still has capacity. This works because optimal assignment never has crossing paths.

Brute Force - Try All Assignments — Algorithm Steps

Generate all valid assignments of robots to factories
For each assignment, calculate total distance
Return minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Assignments

Try assigning each robot to every available factory

Calculate Distance

For each assignment, sum up total travel distances

Find Minimum

Keep track of assignment with minimum total distance

Code -

solution.c — C

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

static int robot[1000];
static int factory[1000][2];
static int factoryUsage[1000];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parse2DArray(const char* str, int factory[][2], int* factorySize) {
    *factorySize = 0;
    const char* p = str + 1; // Start after the opening bracket
    while (*p && *p != ']') {
        if (*p == '[') {
            const char* start = p;
            p++;
            int depth = 1;
            while (*p && depth > 0) {
                if (*p == '[') depth++;
                else if (*p == ']') depth--;
                p++;
            }
            
            int tempArr[10];
            int tempSize;
            char subStr[100];
            int len = p - start;
            strncpy(subStr, start, len);
            subStr[len] = '\0';
            parseArray(subStr, tempArr, &tempSize);
            if (tempSize >= 2) {
                factory[*factorySize][0] = tempArr[0];
                factory[*factorySize][1] = tempArr[1];
                (*factorySize)++;
            }
        } else {
            p++;
        }
    }
}

long long backtrack(int robotIdx, int robotSize, int factorySize) {
    if (robotIdx == robotSize) {
        return 0;
    }
    
    long long minDist = LLONG_MAX;
    for (int i = 0; i < factorySize; i++) {
        if (factoryUsage[i] < factory[i][1]) {
            factoryUsage[i] += 1;
            long long dist = abs(robot[robotIdx] - factory[i][0]) + backtrack(robotIdx + 1, robotSize, factorySize);
            if (dist < minDist) {
                minDist = dist;
            }
            factoryUsage[i] -= 1;
        }
    }
    
    return minDist;
}

long long solution(int robotSize, int factorySize) {
    for (int i = 0; i < factorySize; i++) {
        factoryUsage[i] = 0;
    }
    return backtrack(0, robotSize, factorySize);
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int robotSize;
    parseArray(line1, robot, &robotSize);
    
    int factorySize;
    parse2DArray(line2, factory, &factorySize);
    
    printf("%lld\n", solution(robotSize, factorySize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each robot, we try assigning it to any factory with capacity, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of robots

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

892 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