Minimum steps needed to cover a sequence of points on an infinite grid - GeeksforGeeks

02 Mar, 2022
Given an infinite grid, initial cell position (x, y) and a sequence of other cell position which needs to be covered in the given order. The task is to find the minimum number of steps needed to travel to all those cells.Note: Movement can be done in any of the eight possible directions from a given cell i.e from cell (x, y) you can move to any of the following eight positions:(x-1, y+1), (x-1, y), (x-1, y-1), (x, y-1), (x+1, y-1), (x+1, y), (x+1, y+1), (x, y+1) is possible.
Examples:
Input: points[] = [(0, 0), (1, 1), (1, 2)]Output: 2Move from (0, 0) to (1, 1) in 1 step(diagonal) andthen from (1, 1) to (1, 2) in 1 step (rightwards)
Input: points[] = [{4, 6}, {1, 2}, {4, 5}, {10, 12}]Output: 14Move from (4, 6) -> (3, 5) -> (2, 4) -> (1, 3) ->(1, 2) -> (2, 3) -> (3, 4) ->(4, 5) -> (5, 6) -> (6, 7) ->(7, 8) -> (8, 9) -> (9, 10) -> (10, 11) -> (10, 12)
Approach: Since all the given points are to be covered in the specified order. Find the minimum number of steps required to reach from a starting point to next point, then the sum of all such minimum steps for covering all the points would be the answer. One way to reach from a point (x1, y1) to (x2, y2) is to move abs(x2-x1) steps in the horizontal direction and abs(y2-y1) steps in the vertical direction, but this is not the shortest path to reach (x2, y2). The best way would be to cover the maximum possible distance in a diagonal direction and remaining in horizontal or vertical direction.If we look closely this just reduces to the maximum of abs(x2-x1) and abs(y2-y1). Traverse for all points and summation of all diagonal distance will be the answer.
Below is the implementation of the above approach:
C++
Java
Python3
C#
// C++ program to cover a sequence of points// in minimum steps in a given order.#include <bits/stdc++.h>using namespace std; // cell structure denoted as pointstruct point {    int x, y;}; // function to give minimum steps to// move from point p1 to p2int shortestPath(point p1, point p2){    // dx is total horizontal    // distance to be covered    int dx = abs(p1.x - p2.x);     // dy is total vertical    // distance to be covered    int dy = abs(p1.y - p2.y);     // required answer is    // maximum of these two    return max(dx, dy);} // Function to return the minimum stepsint coverPoints(point sequence[], int size){    int stepCount = 0;     // finding steps for each    // consecutive point in the sequence    for (int i = 0; i < size - 1; i++) {        stepCount += shortestPath(sequence[i],                                  sequence[i + 1]);    }     return stepCount;} // Driver codeint main(){    // arr stores sequence of points    // that are to be visited    point arr[] = { { 4, 6 }, { 1, 2 }, { 4, 5 }, { 10, 12 } };     int n = sizeof(arr) / sizeof(arr[0]);    cout << coverPoints(arr, n);}
// Java program to cover a// sequence of points in// minimum steps in a given order.import java.io.*;import java.util.*;import java.lang.*; // class denoted as pointclass point{    int x, y;    point(int a, int b)    {        x = a;        y = b;             }} class GFG{// function to give minimum// steps to move from point// p1 to p2static int shortestPath(point p1,                        point p2){    // dx is total horizontal    // distance to be covered    int dx = Math.abs(p1.x - p2.x);     // dy is total vertical    // distance to be covered    int dy = Math.abs(p1.y - p2.y);     // required answer is    // maximum of these two    return Math.max(dx, dy);} // Function to return// the minimum stepsstatic int coverPoints(point sequence[],                       int size){    int stepCount = 0;     // finding steps for    // each consecutive    // point in the sequence    for (int i = 0; i < size - 1; i++)    {        stepCount += shortestPath(sequence[i],                                  sequence[i + 1]);    }     return stepCount;} // Driver codepublic static void main(String args[]){    // arr stores sequence of points    // that are to be visited    point arr[] = new point[4];    arr[0] = new point(4, 6);    arr[1] = new point(1, 2);    arr[2] = new point(4, 5);    arr[3] = new point(10, 12);     int n = arr.length;    System.out.print(coverPoints(arr, n));}}
# Python program to cover a sequence of points# in minimum steps in a given order. # function to give minimum steps to# move from pop1 to p2def shortestPath(p1, p2):         # dx is total horizontal    # distance to be covered    dx = abs(p1[0] - p2[0])         # dy is total vertical    # distance to be covered    dy = abs(p1[1] - p2[1])         # required answer is    # maximum of these two    return max(dx, dy)     # Function to return the minimum stepsdef coverPoints(sequence, size):         stepCount = 0         # finding steps for each    # consecutive poin the sequence    for i in range(size-1):        stepCount += shortestPath(sequence[i],sequence[i + 1])             return stepCount # Driver code# arr stores sequence of points# that are to be visitedarr =  [[4, 6] ,[ 1, 2 ], [ 4, 5] , [ 10, 12]]  n = len(arr)print(coverPoints(arr, n)) # This code is contributed by shivanisinghss2110.
// C# program to cover a// sequence of points in// minimum steps in a given order. using System;// class denoted as pointpublic class point{    public int x, y;    public point(int a, int b)    {        x = a;        y = b;              }}  public class GFG{    // function to give minimum    // steps to move from point    // p1 to p2[]    static int shortestPath(point p1,                            point p2)    {        // dx is total horizontal        // distance to be covered        int dx = Math.Abs(p1.x - p2.x);         // dy is total vertical        // distance to be covered        int dy = Math.Abs(p1.y - p2.y);         // required answer is        // maximum of these two        return Math.Max(dx, dy);    }     // Function to return    // the minimum steps    static int coverPoints(point []sequence,                           int size)    {        int stepCount = 0;         // finding steps for        // each consecutive        // point in the sequence        for (int i = 0; i < size - 1; i++)        {            stepCount += shortestPath(sequence[i],                                      sequence[i + 1]);        }         return stepCount;    }     // Driver code    public static void Main()    {        // arr stores sequence of points        // that are to be visited        point []arr = new point[4];        arr[0] = new point(4, 6);        arr[1] = new point(1, 2);        arr[2] = new point(4, 5);        arr[3] = new point(10, 12);         int n = arr.Length;        Console.WriteLine(coverPoints(arr, n));    }}// This code is contributed by Rajput-Ji
# Traversing from one point to another point# storing the minimum number of stepsdef traversal_steps(points):    minSteps = 0    for p in range(len(points)-1):           # taking the manhattan distance between        # x and y-coordinates        d1 = abs(points[p][0] - points[p+1][0])        d2 = abs(points[p][1] - points[p+1][1])               # adding the maximum among the two to the        # running steps parameter        minSteps += max(d1,d2)    return (minSteps) # Main Driver Codeif __name__ == '__main__':    points = [(0,0),(1,1),(1,2)]    print (traversal_steps(points))    points = [(4,6),(1,2),(4,5),(10,12)]    print (traversal_steps(points))
<script>// JacaScript program to cover a sequence of points// in minimum steps in a given order. // function to give minimum steps to// move from pop1 to p2function shortestPath(p1, p2){         // dx is total horizontal    // distance to be covered    let dx = Math.abs(p1[0] - p2[0])         // dy is total vertical    // distance to be covered    let dy = Math.abs(p1[1] - p2[1])         // required answer is    // maximum of these two    return Math.max(dx, dy) }     // Function to return the minimum stepsfunction coverPoints(sequence, size){         let stepCount = 0         // finding steps for each    // consecutive poin the sequence    for(let i=0;i<(size-1);i++)        stepCount += shortestPath(sequence[i],sequence[i + 1])             return stepCount } // Driver code// arr stores sequence of points// that are to be visitedlet arr = [[4, 6] ,[ 1, 2 ], [ 4, 5] , [ 10, 12]] let n = arr.lengthdocument.write(coverPoints(arr, n)) // This code is contributed by shivanisinghss2110.</script>
14

Time Complexity: O(N)
Rajput-Ji
Vikas Chitturi
shivanisinghss2110
shinjanpatra
Greedy Algorithms
math
Mathematical
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples
Program to find sum of elements in a given array
Program for factorial of a number
Operators in C / C++
Euclidean algorithms (Basic and Extended)
Efficient program to print all prime factors of a given number
Find minimum number of coins that make a given value
Minimum number of jumps to reach end
Print all possible combinations of r elements in a given array of size n