# 2463. Minimum Total Distance Traveled

## Problem Description

In the given LeetCode problem, we are tasked with finding the minimum total distance that a set of robots need to travel to reach a group of factories for repairs. We are given two key pieces of information:

1. An integer array called `robot`, which contains the unique starting positions of robots along an X-axis.
2. A 2D integer array called `factory`, where each sub-array `[position_j, limit_j]` represents the unique location of the `j-th` factory (`position_j`) and the maximum number of robots it can repair (`limit_j`).

The robots are initially not operational and will move along the X-axis, either in the positive or negative direction, until they reach a factory that has not reached its repair limit, where they are then repaired and stop moving.

The goal is to set the initial moving direction for the robots in such a way that the total distance all robots travel is minimized. We also need to adhere to several rules:

• All robots move at the same speed and won't collide with each other, regardless of the direction they are moving in.
• If a factory has reached its limit, the robots will consider it non-existent and move past it.
• The distance traveled by a robot is measured as the absolute difference between its starting position and its final position.

We are assured by the problem statement that all robots can be repaired eventually.

## Intuition

To develop an intuition for the solution, we need to approach the problem systematically. The problem possesses optimal substructure and an overlapping subproblems property, making it ideal for a dynamic programming approach. The solution breaks down the problem into smaller instances and reuses the solutions to these instances to build up an answer to the original problem.

Here's the intuition behind the solution:

### Dynamic Programming

Since all robots will eventually be repaired, our task focuses on the sequence and direction we should assign to each robot to minimize the distance traveled. We have to consider the impact of each choice using a dynamic programming approach since the choice of direction for one robot may affect the subsequent choices for other robots.

### Recursive Depth-First Search with Memoization

The solution uses a recursive approach with memoization to explore all the different ways we can match robots to factories. This means we will attempt to repair the robots with different sequences of factories, caching the results to avoid re-computation. The recursive function `dfs(i, j)` represents the minimum distance from the `i-th` robot reaching the `j-th` factory onward.

### Sorting

Both the `robot` and `factory` arrays are sorted to facilitate an orderly examination of the robots and factories. This helps in minimizing the back and forth movement and coordinating the repairs in a systematic manner.

### Decision Making and Minimization

At each step, we decide whether to consider the current factory for repairing the robot or move to the next factory without repairing. This is where we compare:

• The distance if we decide to skip the current factory (just calling `dfs(i, j + 1)`)
• The cumulative distance if we repair one or more robots at the current factory (summarized by the variable `t` and recursive calls like `t + dfs(i + k + 1, j + 1)`).

These recursive calls will thus consider all ways of repairing robots across the factories to find the minimum total distance.

In conclusion, the provided solution employs dynamic programming approach specifically through recursion and memoization, iterating through combinations of robots reaching factories while aiming to minimize the total distance traveled by the robots.

## Solution Approach

The solution to this problem employs an algorithmic technique known as Depth-First Search (DFS) with memoization, which is a form of caching. Below is a detailed description of how the algorithm is implemented through the given solution code:

### Sorting the Arrays

Firstly, the `robot` and `factory` arrays are sorted. This is essential to ensure we are always moving forward with our decisions. It simplifies the decision-making process since both robots and factories are considered in ascending order of their positions on the X-axis.

### The Recursive Function `dfs`

The `dfs(i, j)` function is at the heart of the solution and it performs the following actions:

• Base Cases:

• If `i == len(robot)`, all the robots are accounted for and repaired, hence the distance is `0`.
• If `j == len(factory)`, there are no more factories available, so the returned distance is `infinity` (`inf`).
• Recursion and Decision Making:

• We initially set `ans` to the result of the recursive call `dfs(i, j + 1)`, which means considering the next factory without repairing the current robot at the current factory. This represents not using the `j-th` factory for the `i-th` robot.
• Then, in the for loop, we iteratively check how the total distance changes if we decide to repair up to `factory[j][1]` number of robots at the `j-th` factory. The variable `t` stores the total distance if the `k-th` robot is repaired by the current factory.
• We then recursively calculate the remaining distance using `dfs(i + k + 1, j + 1)` which represents the distance for the remaining robots being potentially repaired by the next factories.
• `ans` is updated to the minimum of its current value and the new distance calculated and this continues recursively.

### Dynamic Programming with Memoization

To avoid recalculating the distance for the same state of robots and factories, we employ memoization using the `@cache` decorator from Python's `functools` module. This ensures that once a particular combination of `i` and `j` has been computed, it will not be recalculated if called upon again.

After calling the `dfs` function starting with the first robot and the first factory (`dfs(0, 0)`), the program clears the cache to free up memory, and then returns the calculated minimum total distance.

### Data Structure and Patterns

• A recursive depth-first search function (`dfs`) is used to explore possible scenarios recursively.
• A memoization technique (with the `@cache` decorator) is used to remember solutions to subproblems.
• Lists: The `robot` and `factory` lists are used to keep track of robots' positions and factories' capacities and positions, respectively.
• Sorting: Both lists are sorted to organize the decision-making process.
• Mathematical operations: Simple arithmetic and the absolute value function (`abs`) are used to calculate distances.

By integrating these algorithms, data structures, and patterns, the solution efficiently explores the optimal way of minimizing the total distance traveled by all the robots to the factories for repair.

### Example Walkthrough

Let's consider a small example to illustrate the solution approach outlined earlier.

Suppose we have the following input data:

• `robot = [4, 0, 5]`: The robots are located at positions 4, 0, and 5 on the X-axis.
• `factory = [[1, 1], [3, 2]]`: There are two factories. The first is located at position 1 and can repair 1 robot whereas the second one is located at position 3 and can repair up to 2 robots.

#### Step 1: Sorting the Arrays

First, we sort both arrays to make sure our decisions are based on ascending order.

• Sorted `robot = [0, 4, 5]`
• Sorted `factory = [[1, 1], [3, 2]]`

#### Step 2: Calling `dfs` Function

We start our recursive Depth-First Search with the `dfs` function `dfs(0, 0)` considering the first robot and the first factory.

#### Step 3: Making Decisions in `dfs`

• For the first robot at position 0, using the first factory at position 1:

• If we decide not to repair the robot at the first factory (`dfs(i, j + 1)`, i.e., `dfs(0, 1)`), the robot will go to the next factory located at position 3. The distance traveled by this robot will now be calculated in subsequent recursive calls.
• We also check if we can repair this robot at the current factory (`dfs(i + 1, j + 1)`, i.e., `dfs(1, 1)`) by adding the distance to reach the current factory from position 0 to 1, which is `1`. Then we calculate the cost for the remaining robots using subsequent recursive calls.
• For the second robot at position 4, with the second factory (already moving to factory j+1 from previous step):

• We check if it can be repaired at the second factory located at position 3 (`dfs(i + 1, j + 1)`, i.e., `dfs(2, 1)`), for this we consider the distance `1` (from position 4 to 3) and then explore further recursive calls for the remaining robot.
• For the third robot at position 5, it only has the second factory available:

• If we repair it at the second factory, the distance is `2` (from position 5 to 3). This is the distance for our last robot as there are no more robots to consider `(dfs(i + 1, j + 1)`, i.e., `dfs(3, 1))`, and thus it ends the recursive calls.

#### Step 4: Minimization and Memoization

• During each recursive call, we compare distances to decide whether to use or skip the current factory. These distances are stored via memoization to avoid recomputation.
• For the given example, the minimum distances would be calculated for each possibility, and the one yielding the lowest total distance would be returned.

After all recursive calls have been made and the minimum total distance is computed, `dfs(0, 0)` will return this value representing the minimum total distance for all robots to be repaired.

For this simple example, one optimal decision might be to repair the second and third robots at the second factory and the first robot at the first factory resulting in a total distance of `1 (first robot to first factory) + 1 (second robot to second factory) + 2 (third robot to second factory) = 4`. This is the minimum distance considering all constraints and the capability of factories.

## Solution Implementation

``````1from typing import List
2from functools import cache
3import math
4
5class Solution:
6    def minimumTotalDistance(self, robots: List[int], factories: List[List[int]]) -> int:
7        # Use 'cache' to memorize results of the recursive calls to 'dp' to avoid recalculating.
8        @cache
9        def dp(robot_index, factory_index):
10            # Base case: all robots have been paired with a factory.
11            if robot_index == len(robots):
12                return 0
13            # Base case: no more factories to pair with, return infinity as this path not possible.
14            if factory_index == len(factories):
15                return math.inf
16
17            # Calculate the distance without including the current factory.
18            answer = dp(robot_index, factory_index + 1)
19
20            # Initialize the total distance when starting to pair robots with the current factory.
21            total_distance = 0
22
23            # Loop through each quantity unit in the factory.
24            for unit in range(factories[factory_index][1]):
25                # If there are no more robots to pair, break the loop.
26                if robot_index + unit == len(robots):
27                    break
28
29                # Calculate the distance from the current robot unit to the factory.
30                total_distance += abs(robots[robot_index + unit] - factories[factory_index][0])
31
32                # Choose the minimum distance by either skipping this factory or pairing with it.
33                answer = min(answer, total_distance + dp(robot_index + unit + 1, factory_index + 1))
34
36
37        # Sort the arrays to make the pairing logic straightforward.
38        robots.sort()
39        factories.sort(key=lambda x: x[0])  # Sort factories by location only.
40
41        # Call the memoized recursive function starting from the first robot and the first factory.
42        ans = dp(0, 0)
43
44        # Clear the cache after computation to release memory.
45        dp.cache_clear()
46
47        # Return the computed minimum total distance.
48        return ans
49
50# Example usage:
51# sol = Solution()
52# minimum_distance = sol.minimumTotalDistance([1,3,10], [[2,2],[5,3]])
53# print(minimum_distance)  # this should output the minimum total distance
54``````
``````1import java.util.Collections;
2import java.util.List;
3import java.util.Arrays;
4
5class Solution {
6    private long[][] memo; // memoization table to store computed values
7    private List<Integer> robots; // list storing robot positions
8    private int[][] factories; // 2D array storing factory positions and capacities
9
10    // Computes the minimum total distance that robots must travel to factories
11    public long minimumTotalDistance(List<Integer> robots, int[][] factories) {
12        Collections.sort(robots);
13        // Sort factories based on their positions (x-coordinate)
14        Arrays.sort(factories, (a, b) -> a[0] - b[0]);
15
16        this.robots = robots;
17        this.factories = factories;
18        // Initialize the memoization table with robot size and factory length dimensions
19        memo = new long[robots.size()][factories.length];
20        return dfs(0, 0); // Begin the depth-first search from the start
21    }
22
23    // Depth-first search function to find minimum distance recursively
24    private long dfs(int robotIndex, int factoryIndex) {
25        // If all robots have been assigned to factories, no distance to cover
26        if (robotIndex == robots.size()) {
27            return 0;
28        }
29        // If there are no more factories to consider, return a large number to signify an invalid path
30        if (factoryIndex == factories.length) {
31            return Long.MAX_VALUE / 1000; // Large value to avoid overflow when further added
32        }
33        // If the value has been computed before, return it
34        if (memo[robotIndex][factoryIndex] != 0) {
35            return memo[robotIndex][factoryIndex];
36        }
37
38        // Recursive case: compare not assigning any more robots to current factory vs assigning more robots
39        long ans = dfs(robotIndex, factoryIndex + 1); // Case of not assigning the robot to the current factory
40
41        long distanceSum = 0; // Variable to keep the sum of distances if current factory is selected
42        // Check assigning robots to this factory based on its capacity
43        for (int k = 0; k < factories[factoryIndex][1]; ++k) {
44            if (robotIndex + k == robots.size()) {
45                break; // Break if there are no more robots to assign
46            }
47            // Add the distance of the k-th robot to the current factory to distanceSum
48            distanceSum += Math.abs(robots.get(robotIndex + k) - factories[factoryIndex][0]);
49            ans = Math.min(ans, distanceSum + dfs(robotIndex + k + 1, factoryIndex + 1));
50        }
51        memo[robotIndex][factoryIndex] = ans; // Memoize the computed result
52
53        return ans; // Return the minimum distance for the current state
54    }
55}
56``````
``````1#include <vector>
2#include <algorithm>
3#include <functional>
4#include <cmath>
5
6using ll = long long;
7
8class Solution {
9public:
10    long long minimumTotalDistance(vector<int>& robots, vector<vector<int>>& factories) {
11        // Sort both the robot and factory vectors to have the elements in ascending order.
12        sort(robots.begin(), robots.end());
13        sort(factories.begin(), factories.end());
14
15        // Create a 2D vector to store the minimum total distance for given i and j.
16        vector<vector<ll>> memo(robots.size(), vector<ll>(factories.size(), 0));
17
18        // Define a recursive lambda function to calculate the minimum total distance.
19        std::function<ll(int, int)> calculateMinDistance = [&](int robotIndex, int factoryIndex) -> ll {
20            // If all robots have been assigned, there's no additional cost.
21            if (robotIndex == robots.size()) return 0;
22            // If all factories have been considered and not all robots are assigned, assign high cost.
23            if (factoryIndex == factories.size()) return 1e15;
24
25            // If the answer for this state is already computed, return it.
26            if (memo[robotIndex][factoryIndex] != 0) return memo[robotIndex][factoryIndex];
27
28            // Check next factory without assigning the current one.
29            ll answer = calculateMinDistance(robotIndex, factoryIndex + 1);
30            ll tempDistance = 0;
31
32            // Try assigning robots to the current factory and calculate the total distance.
33            for (int k = 0; k < factories[factoryIndex][1]; ++k) {
34                // If all robots are assigned, break the loop.
35                if (robotIndex + k >= robots.size()) break;
36                // Add distance for the current robot to the temp variable.
37                tempDistance += std::abs(robots[robotIndex + k] - factories[factoryIndex][0]);
38                // Recursively calculate the minimum total distance for the remaining robots and factories.
39                answer = std::min(answer, tempDistance + calculateMinDistance(robotIndex + k + 1, factoryIndex + 1));
40            }
41
42            // Save the result in the memoization table and return it.
45        };
46
47        // Start the recursion with the initial state, which is starting with the first robot and first factory.
48        return calculateMinDistance(0, 0);
49    }
50};
51``````
``````1// Importing modules and functions needed
2import { sort } from './sort'; // assuming a sort function is available
3import { abs } from './math'; // assuming an abs function is available
4
6type ll = number;
7
8// Define the array of robots and factories as global variables
9let robots: number[];
10let factories: number[][];
11
12// Create a 2D array to store the minimum total distance for given i and j.
13let memo: ll[][];
14
15// A lambda function to calculate the minimum total distance.
16const calculateMinDistance: (robotIndex: number, factoryIndex: number) => ll = (robotIndex, factoryIndex) => {
17    // If all robots have been assigned, there's no additional cost.
18    if (robotIndex === robots.length) return 0;
19    // If all factories have been considered and not all robots are assigned, assign high cost.
20    if (factoryIndex === factories.length) return 1e15;
21
22    // If the answer for this state is already computed, return it.
23    if (memo[robotIndex][factoryIndex] !== 0) return memo[robotIndex][factoryIndex];
24
25    // Check next factory without assigning the current one.
26    let answer = calculateMinDistance(robotIndex, factoryIndex + 1);
27    let tempDistance = 0;
28
29    // Try assigning robots to the current factory and compute the total distance.
30    for (let k = 0; k < factories[factoryIndex][1]; ++k) {
31        // If all robots are assigned, break the loop.
32        if (robotIndex + k >= robots.length) break;
33        // Add distance for the current robot to the temp variable.
34        tempDistance += abs(robots[robotIndex + k] - factories[factoryIndex][0]);
35        // Recursively calculate the minimum total distance for the remaining robots and factories.
36        answer = Math.min(answer, tempDistance + calculateMinDistance(robotIndex + k + 1, factoryIndex + 1));
37    }
38
39    // Save the result in the memoization table and return it.
42};
43
44// The main function to calculate the minimum total distance between robots and factories.
45const minimumTotalDistance = (inputRobots: number[], inputFactories: number[][]): ll => {
46    // Assign global variables with input values
47    robots = inputRobots;
48    factories = inputFactories;
49
50    // Sort robots and factories by their respective location values in ascending order.
51    sort(robots); // Assuming a sort function is defined
52    // Need to sort based on the location which is the first element of the inner arrays
53    sort(factories, (a, b) => a[0] - b[0]);
54
55    // Initialize the memo array with zeroes
56    memo = Array.from({ length: robots.length }, () => Array(factories.length).fill(0));
57
58    // Start the recursion with the first robot and first factory.
59    return calculateMinDistance(0, 0);
60};
61
62// Export the function for use in other modules if required.
63export { minimumTotalDistance };
64``````

## Time and Space Complexity

### Time Complexity

The time complexity of the algorithm can be broken down based on the two key operations: the depth-first search (DFS) through the `dfs` function and the sorting operations on the `robot` and `factory` lists.

1. Sorting the `robot` and `factory` lists have a time complexity of `O(NlogN)` and `O(MlogM)` respectively, where `N` is the number of elements in `robot` and `M` is the number of lists within the `factory`.

2. The DFS operation, which includes a nested loop, is more complex. The function `dfs(i, j)` is a memoized recursive function that explores each pair of positions in `robot` and `factory`. The memoization is done using `@cache`, which ensures that each (i, j) pair is computed only once.

3. The DFS explores at worst each pair of `i` in `robot` and `j` in `factory`, and an additional nested loop iterates up to `factory[j][1]` times. Considering worst-case scenario, for each call to dfs, loops up to the size of the second dimension of the factory, the total number of recursive calls to `dfs(i, j)` can be roughly estimated as `O(N * max_factory_size)`, where `max_factory_size` refers to the maximum value of `factory[j][1]` across all `factory`.

4. Since the DFS is memoized, each pair `(i, j)` is computed once, leading to there being `O(N * M)` unique calls to `dfs`. Within each call, the worst-case takes `O(max_factory_size)` operations, leading to a total rough estimate of `O(N * M * max_factory_size)` for the DFS.

5. Hence, combining the sorting and the DFS, the total time complexity is `O(NlogN + MlogM + N * M * max_factory_size)`.

### Space Complexity

The space complexity of the algorithm also arises from two sources: the sorting and the memoization used in DFS.

1. Sorting takes `O(1)` space as it can be done in-place.

2. The space complexity of the DFS involves the space taken by the recursion call stack and the memoization.

3. The call stack at any time holds at most `O(N)` frames, since that is the maximum depth of recursion.

4. The cache used by memoization will hold at most `O(N * M)` entries, corresponding to the unique states of the `(i, j)` pair.

5. Therefore, the total space complexity is `O(N * M)`, dominated by the `@cache`'s memoization requirement.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:
Question 1 out of 10

Which of the following is a good use case for backtracking?