File: minimum-time-visiting-all-points/solution.py

Date: 2026-06-06

Time: 18:03

minimum-time-visiting-all-points/solution.py

Purpose

Solves LeetCode 1266 — Minimum Time Visiting All Points. The file owns a single function that computes the minimum time (in seconds) to visit an ordered sequence of 2D points, where each second you can move one step in any of 8 directions (including diagonals).

Key Components

minTimeToVisitAllPoints(points: list[list[int]]) -> int — The sole public function. Takes an ordered list of [x, y] coordinate pairs and returns the total minimum traversal time.

Contract: points must contain at least one element. The function visits points in the given order (no reordering optimization).

Patterns

Chebyshev distance. The core insight is that the minimum time to travel between two points on an infinite 2D grid with 8-directional movement equals the Chebyshev distance: max(|dx|, |dy|). Diagonal moves let you close both the x-gap and y-gap simultaneously, so the bottleneck is whichever axis has the larger delta.

Pairwise reduction. The function sums Chebyshev distances over consecutive pairs using a generator expression with index arithmetic (points[i+1] vs points[i]), rather than zip or itertools.pairwise. This is a common LeetCode idiom — functional but slightly less Pythonic than sum(max(...) for a, b in pairwise(points)).

Dependencies

Imports: None — pure computation with no standard library or third-party dependencies.

Imported by: minimum-time-visiting-all-points/test_solution.py (directly), plus ~400+ other test files listed in the repo context. That "imported by" list is likely an artifact of the repo's test harness importing a shared runner or conftest, not actual usage of this function.

Flow

1. Iterate i from 0 to len(points) - 2.

2. For each consecutive pair (points[i], points[i+1]), compute the absolute x-difference and absolute y-difference.

3. Take the max of those two deltas — this is the Chebyshev distance.

4. Sum all pairwise distances and return.

Single-pass, O(n) time, O(1) space.

Invariants

• Points are visited in order — this is a constraint of the problem, not a choice the algorithm makes. No shortest-path or TSP optimization is applied.
• The function assumes points has at least 1 element. With a single point the generator is empty, sum returns 0, which is correct.

Error Handling

None. An empty points list produces 0 (vacuous sum). Invalid inputs (non-numeric, wrong nesting) would raise at the abs() or indexing level with standard Python exceptions — no guarding is done, which is typical for LeetCode solutions.

Topics to Explore

• [general] chebyshev-vs-manhattan-distance — Why max(|dx|, |dy|) is correct for 8-directional movement versus |dx| + |dy| for 4-directional
• [file] minimum-time-visiting-all-points/test_solution.py — Verify which edge cases are covered (single point, collinear points, negative coordinates)
• [file] minimum-time-visiting-all-points/plan.md — See the original problem decomposition and whether alternative approaches were considered
• [general] itertools.pairwise-refactor — Whether the repo uses pairwise elsewhere and if this solution could adopt it for consistency

Beliefs

• chebyshev-distance-for-8dir-grid — The minimum steps between two points on an 8-directional grid equals max(|dx|, |dy|), not |dx| + |dy|
• visit-order-is-fixed — The solution visits points strictly in input order; it does not solve the traveling salesman problem
• linear-time-constant-space — The algorithm runs in O(n) time and O(1) auxiliary space over the points list
• no-external-dependencies — The solution uses only Python builtins with zero imports