给定无限网格，需要按给定顺序覆盖初始像元位置(x，y)和其他像元位置序列。任务是找到前往所有这些单元所需的最少步数。
注意：可以从给定的单元格在八个可能的方向上进行移动，即从单元格(x，y)可以移动到以下八个位置中的任何一个：(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)是可能的。
例子：
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)
方法：由于所有给定点均应按指定顺序覆盖。找到从起点到下一个点所需的最小步数，然后覆盖所有点的所有最小步数的总和就是答案。从点(x1，y1)到达(x2，y2)的一种方法是在水平方向上移动abs(x2-x1)步长，在垂直方向上移动abs(y2-y1)步长，但这不是到达(x2，y2)的最短路径。最好的方法是覆盖对角线方向上的最大可能距离，并保持水平或垂直方向上的距离。
如果我们仔细观察，这只会减少到abs(x2-x1)和abs(y2-y1)的最大值。答案就是所有点的遍历和所有对角线距离的总和。
下面是上述方法的实现：
C++
// C++ program to cover a sequence of points
// in minimum steps in a given order.
#include
using namespace std;
// cell structure denoted as point
struct point {
int x, y;
};
// function to give minimum steps to
// move from point p1 to p2
int 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 steps
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
int 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
// 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 point
class 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 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(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));
}
}Python3
# 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 p2
def 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 steps
def 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 visited
arr = [[4, 6] ,[ 1, 2 ], [ 4, 5] , [ 10, 12]]
n = len(arr)
print(coverPoints(arr, n))
# This code is contributed by shivanisinghss2110.C#
// C# program to cover a
// sequence of points in
// minimum steps in a given order.
using System;
// class denoted as point
public 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 steps
def 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 Code
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))输出：
14
时间复杂度： O(N)