Minimum steps needed to cover a sequence of points on an infinite grid
Last Updated :
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: 2
Move from (0, 0) to (1, 1) in 1 step(diagonal) and
then from (1, 1) to (1, 2) in 1 step (rightwards)
Input: points[] = [{4, 6}, {1, 2}, {4, 5}, {10, 12}]
Output: 14
Move 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++
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
int shortestPath(point p1, point p2)
{
int dx = abs (p1.x - p2.x);
int dy = abs (p1.y - p2.y);
return max(dx, dy);
}
int coverPoints(point sequence[], int size)
{
int stepCount = 0;
for ( int i = 0; i < size - 1; i++) {
stepCount += shortestPath(sequence[i],
sequence[i + 1]);
}
return stepCount;
}
int main()
{
point arr[] = { { 4, 6 }, { 1, 2 }, { 4, 5 }, { 10, 12 } };
int n = sizeof (arr) / sizeof (arr[0]);
cout << coverPoints(arr, n);
}
|
Java
import java.io.*;
import java.util.*;
import java.lang.*;
class point
{
int x, y;
point( int a, int b)
{
x = a;
y = b;
}
}
class GFG
{
static int shortestPath(point p1,
point p2)
{
int dx = Math.abs(p1.x - p2.x);
int dy = Math.abs(p1.y - p2.y);
return Math.max(dx, dy);
}
static int coverPoints(point sequence[],
int size)
{
int stepCount = 0 ;
for ( int i = 0 ; i < size - 1 ; i++)
{
stepCount += shortestPath(sequence[i],
sequence[i + 1 ]);
}
return stepCount;
}
public static void main(String args[])
{
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));
}
}
|
Python3
def shortestPath(p1, p2):
dx = abs (p1[ 0 ] - p2[ 0 ])
dy = abs (p1[ 1 ] - p2[ 1 ])
return max (dx, dy)
def coverPoints(sequence, size):
stepCount = 0
for i in range (size - 1 ):
stepCount + = shortestPath(sequence[i],sequence[i + 1 ])
return stepCount
arr = [[ 4 , 6 ] ,[ 1 , 2 ], [ 4 , 5 ] , [ 10 , 12 ]]
n = len (arr)
print (coverPoints(arr, n))
|
C#
using System;
public class point
{
public int x, y;
public point( int a, int b)
{
x = a;
y = b;
}
}
public class GFG
{
static int shortestPath(point p1,
point p2)
{
int dx = Math.Abs(p1.x - p2.x);
int dy = Math.Abs(p1.y - p2.y);
return Math.Max(dx, dy);
}
static int coverPoints(point []sequence,
int size)
{
int stepCount = 0;
for ( int i = 0; i < size - 1; i++)
{
stepCount += shortestPath(sequence[i],
sequence[i + 1]);
}
return stepCount;
}
public static void Main()
{
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));
}
}
|
def traversal_steps(points):
minSteps = 0
for p in range ( len (points) - 1 ):
d1 = abs (points[p][ 0 ] - points[p + 1 ][ 0 ])
d2 = abs (points[p][ 1 ] - points[p + 1 ][ 1 ])
minSteps + = max (d1,d2)
return (minSteps)
if __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>
function shortestPath(p1, p2){
let dx = Math.abs(p1[0] - p2[0])
let dy = Math.abs(p1[1] - p2[1])
return Math.max(dx, dy)
}
function coverPoints(sequence, size){
let stepCount = 0
for (let i=0;i<(size-1);i++)
stepCount += shortestPath(sequence[i],sequence[i + 1])
return stepCount
}
let arr = [[4, 6] ,[ 1, 2 ], [ 4, 5] , [ 10, 12]]
let n = arr.length
document.write(coverPoints(arr, n))
</script>
|
Time Complexity: O(N)
Share your thoughts in the comments
Please Login to comment...