package com.fishercoder.solutions;

/**
 * 1266. Minimum Time Visiting All Points
 *
 * On a plane there are n points with integer coordinates points[i] = [xi, yi].
 * Your task is to find the minimum time in seconds to visit all points.
 *
 * You can move according to the next rules:
 * In one second always you can either move vertically, horizontally by one unit or diagonally
 * (it means to move one unit vertically and one unit horizontally in one second).
 * You have to visit the points in the same order as they appear in the array.
 *
 * 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
 * */
public class _1266 {
    public static class Solution1 {
        /**
         * Time: O(n)
         * Space: O(1)
         *
         * credit: https://leetcode.com/problems/minimum-time-visiting-all-points/discuss/436142/Sum-of-Chebyshev-distance-between-two-consecutive-points
         * */
        public int minTimeToVisitAllPoints(int[][] points) {
            int minTime = 0;
            for (int i = 0; i < points.length - 1; i++) {
                minTime += chebyshevDistance(points[i], points[i + 1]);
            }
            return minTime;
        }

        private int chebyshevDistance(int[] pointA, int[] pointB) {
            return Math.max(Math.abs(pointA[0] - pointB[0]), Math.abs(pointA[1] - pointB[1]));
        }
    }
}

@@ -33,998 +33,8 @@
 s;%0A%0A
-/**%0A * 1266. Minimum Time Visiting All Points%0A *%0A * On a plane there are n points with integer coordinates points%5Bi%5D = %5Bxi, yi%5D.%0A * Your task is to find the minimum time in seconds to visit all points.%0A *%0A * You can move according to the next rules:%0A * In one second always you can either move vertically, horizontally by one unit or diagonally%0A * (it means to move one unit vertically and one unit horizontally in one second).%0A * You have to visit the points in the same order as they appear in the array.%0A *%0A * Example 1:%0A * Input: points = %5B%5B1,1%5D,%5B3,4%5D,%5B-1,0%5D%5D%0A * Output: 7%0A * Explanation: One optimal path is %5B1,1%5D -%3E %5B2,2%5D -%3E %5B3,3%5D -%3E %5B3,4%5D -%3E %5B2,3%5D -%3E %5B1,2%5D -%3E %5B0,1%5D -%3E %5B-1,0%5D%0A * Time from %5B1,1%5D to %5B3,4%5D = 3 seconds%0A * Time from %5B3,4%5D to %5B-1,0%5D = 4 seconds%0A * Total time = 7 seconds%0A *%0A * Example 2:%0A * Input: points = %5B%5B3,2%5D,%5B-2,2%5D%5D%0A * Output: 5%0A *%0A * Constraints:%0A * points.length == n%0A * 1 %3C= n %3C= 100%0A * points%5Bi%5D.length == 2%0A * -1000 %3C= points%5Bi%5D%5B0%5D, points%5Bi%5D%5B1%5D %3C= 1000%0A * */%0A
 publ
@@ -153,16 +153,20 @@
        *
+ %3Cp%3E
 %0A       
@@ -312,24 +312,24 @@
 -points%0A
+
         
  * */%0A  
@@ -320,18 +320,16 @@
         
- *
  */%0A    

refactor 1266