Skip to content

1266. Minimum Time Visiting All Points

Description

On a 2D plane, there are n points with integer coordinates points[i] = [xi, yi]. Return the minimum time in seconds to visit all the points in the order given by points.

You can move according to these rules:

  • In 1 second, you can either:
    • move vertically by oneΒ unit,
    • move horizontally by one unit, or
    • move diagonally sqrt(2) units (in other words, move one unit vertically then one unit horizontally in 1 second).
  • You have to visit the points in the same order as they appear in the array.
  • You are allowed to pass through points that appear later in the order, but these do not count as visits.

Β 

Example 1:

Input: points = [[1,1],[3,4],[-1,0]]
Output: 7
Explanation: One optimal path is [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]   
Time from [1,1] to [3,4] = 3 seconds 
Time from [3,4] to [-1,0] = 4 seconds
Total time = 7 seconds

Example 2:

Input: points = [[3,2],[-2,2]]
Output: 5

Β 

Constraints:

  • points.length == n
  • 1 <= nΒ <= 100
  • points[i].length == 2
  • -1000Β <= points[i][0], points[i][1]Β <= 1000

Solutions

Solution 1: Simulation

For two points \(p_1=(x_1, y_1)\) and \(p_2=(x_2, y_2)\), the distances moved in the horizontal and vertical directions are \(d_x = |x_1 - x_2|\) and \(d_y = |y_1 - y_2|\) respectively.

If \(d_x \ge d_y\), we move diagonally for \(d_y\) steps, then move horizontally for \(d_x - d_y\) steps; if \(d_x < d_y\), we move diagonally for \(d_x\) steps, then move vertically for \(d_y - d_x\) steps. Therefore, the shortest distance between two points is \(\max(d_x, d_y)\).

We can iterate through all pairs of points, calculate the shortest distance between each pair, and sum them up.

The time complexity is \(O(n)\), where \(n\) is the number of points. The space complexity is \(O(1)\).

1
2
3
4
5
class Solution:
    def minTimeToVisitAllPoints(self, points: List[List[int]]) -> int:
        return sum(
            max(abs(p1[0] - p2[0]), abs(p1[1] - p2[1])) for p1, p2 in pairwise(points)
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
    public int minTimeToVisitAllPoints(int[][] points) {
        int ans = 0;
        for (int i = 1; i < points.length; ++i) {
            int dx = Math.abs(points[i][0] - points[i - 1][0]);
            int dy = Math.abs(points[i][1] - points[i - 1][1]);
            ans += Math.max(dx, dy);
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution {
public:
    int minTimeToVisitAllPoints(vector<vector<int>>& points) {
        int ans = 0;
        for (int i = 1; i < points.size(); ++i) {
            int dx = abs(points[i][0] - points[i - 1][0]);
            int dy = abs(points[i][1] - points[i - 1][1]);
            ans += max(dx, dy);
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func minTimeToVisitAllPoints(points [][]int) (ans int) {
    for i, p := range points[1:] {
        dx := abs(p[0] - points[i][0])
        dy := abs(p[1] - points[i][1])
        ans += max(dx, dy)
    }
    return
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

1
2
3
4
5
6
7
8
9
function minTimeToVisitAllPoints(points: number[][]): number {
    let ans = 0;
    for (let i = 1; i < points.length; i++) {
        const dx = Math.abs(points[i][0] - points[i - 1][0]);
        const dy = Math.abs(points[i][1] - points[i - 1][1]);
        ans += Math.max(dx, dy);
    }
    return ans;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
impl Solution {
    pub fn min_time_to_visit_all_points(points: Vec<Vec<i32>>) -> i32 {
        let mut ans = 0;
        for i in 1..points.len() {
            let dx = (points[i][0] - points[i - 1][0]).abs();
            let dy = (points[i][1] - points[i - 1][1]).abs();
            ans += dx.max(dy);
        }
        ans
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#define max(a, b) ((a) > (b) ? (a) : (b))

int minTimeToVisitAllPoints(int** points, int pointsSize, int* pointsColSize) {
    int ans = 0;
    for (int i = 1; i < pointsSize; ++i) {
        int dx = abs(points[i][0] - points[i - 1][0]);
        int dy = abs(points[i][1] - points[i - 1][1]);
        ans += max(dx, dy);
    }
    return ans;
}

Comments