Re the ghost logic in chasing.c:

If the goal is to minimize the **maximum distance** traveled by any one actor (starting point)
rather than minimizing the total distance, the problem changes to what is called a **bottleneck
assignment problem**. The objective here is to find an assignment of starting points to
destination points that minimizes the largest distance traveled by any actor.

A common approach to solving this is to use **binary search** on the maximum distance in
conjunction with a **bipartite matching algorithm** to check feasibility. Here's how it works:

### Algorithm Outline

1. **Binary Search on Maximum Distance**: 
   - Use binary search to find the smallest possible maximum distance. The search range will be
     between the smallest and largest distances in the given distance matrix.
   
2. **Feasibility Check**: 
   - For each candidate value of the maximum distance (midpoint in the binary search), create a
     graph where there is an edge between a starting point and a destination point if the distance
     between them is less than or equal to the candidate maximum distance.
   - Use a **bipartite matching algorithm** to check if a valid assignment exists for this
     candidate maximum distance.
   - If a valid assignment exists, reduce the maximum distance; otherwise, increase it.

### Step-by-Step Explanation

1. **Binary Search Initialization**:
   - The lower bound of the search (`low`) is the smallest distance in the matrix.
   - The upper bound of the search (`high`) is the largest distance in the matrix.

2. **Binary Search Iteration**:
   - Compute the midpoint of `low` and `high`.
   - For this midpoint, construct a bipartite graph where an edge exists between starting point \( S_i \)
     and destination point \( D_j \) if the distance \( d(i, j) \leq \text{midpoint} \).
   - Run a bipartite matching algorithm (like the **Hungarian algorithm** or a maximum flow algorithm)
     on the graph to see if a valid matching can be found.

3. **Adjust Search Bounds**:
   - If a valid matching is found (i.e., all starting points can be assigned to unique destination points),
     try to reduce the maximum distance by setting `high = midpoint`.
   - If no valid matching is found, increase the maximum allowable distance by setting `low = midpoint + 1`.

4. **Termination**:
   - The binary search terminates when `low` equals `high`, at which point `low` (or `high`) will
     represent the minimum possible maximum distance.

### C-like Pseudo Code

```c
#include <stdbool.h>

#define N 4  // Size of the distance matrix

// Function prototype for a bipartite matching check
bool isMatchingPossible(int maxDistance, int distanceMatrix[N][N]);

// Function to minimize the maximum distance using binary search
int minimizeMaxDistance(int distanceMatrix[N][N]) {
    int low = distanceMatrix[0][0], high = distanceMatrix[0][0];

    // Find the smallest and largest distance in the matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (distanceMatrix[i][j] < low) low = distanceMatrix[i][j];
            if (distanceMatrix[i][j] > high) high = distanceMatrix[i][j];
        }
    }

    // Binary search for the smallest maximum distance
    while (low < high) {
        int mid = (low + high) / 2;

        // Check if a valid matching exists with this max distance
        if (isMatchingPossible(mid, distanceMatrix)) {
            high = mid;  // Try to reduce the maximum distance
        } else {
            low = mid + 1;  // Increase the maximum distance
        }
    }

    return low;  // This will be the minimized maximum distance
}

// Function to check if a valid matching exists with the given maximum distance
bool isMatchingPossible(int maxDistance, int distanceMatrix[N][N]) {
    // Construct a bipartite graph where an edge exists if distance <= maxDistance
    bool graph[N][N] = {false};

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (distanceMatrix[i][j] <= maxDistance) {
                graph[i][j] = true;  // Edge exists
            }
        }
    }

    // Run a bipartite matching algorithm (e.g., Hungarian Algorithm or DFS-based matching)
    // Placeholder for bipartite matching algorithm
    // If a perfect matching exists, return true, else return false

    return true;  // Placeholder return value
}
```

### Key Concepts:

1. **Binary Search on Maximum Distance**:
   - We're using binary search to efficiently search for the minimum possible maximum distance.
     This is similar to binary search on a range of values.
   
2. **Bipartite Matching**:
   - For each value of maximum distance, we construct a bipartite graph and check if all
     starting points can be matched to destination points using edges with distances less
     than or equal to this candidate maximum distance.
   
3. **Feasibility Check**:
   - A feasibility check for a given maximum distance is performed by trying to find a perfect
     matching using a bipartite matching algorithm. This ensures that each starting point can be
     assigned to a unique destination point within the allowable maximum distance.

### Time Complexity:

- The time complexity of this approach is determined by two factors:
  1. **Binary Search**: It takes **O(log D)**, where \( D \) is the range between the smallest
     and largest distances in the matrix.
  2. **Bipartite Matching**: A bipartite matching algorithm can be solved using the **Hungarian
     algorithm** in **O(N^3)** for an \( N \times N \) matrix, or a simpler DFS-based matching in **O(N^2)**.

The overall time complexity is approximately **O(N^3 \log D)**, where \( N \) is the size of
the distance matrix and \( D \) is the range of the distances.

### Conclusion:

The approach outlined here is suitable for minimizing the maximum distance traveled by any actor
using a combination of **binary search** and a **bipartite matching** algorithm. This ensures that
the worst-case distance is minimized while still assigning each starting point to a unique destination point.