访问 N * M 网格的所有角落所需的最少步骤

给定两个整数N和M表示二维网格的维度，以及两个整数R和C表示该网格中块的位置，任务是找到访问网格所有角所需的最少步数, 从(R, C) 开始。在每一步中，允许移动网格中的边相邻块。

例子：

Input: N = 2, M = 2, R = 1, C = 2 
Output: 3

Explanation: 
(1, 2) -> (1, 1) -> (2, 1) -> (2, 2) 
Therefore, the required output is 3.

Input: N = 2, M = 3, R = 2, C = 2 
Output: 5 
Explanation: 
(2, 2) -> (2, 3) -> (1, 3) -> (1, 2) -> (1, 1) -> (2, 1) 
Therefore, the required output is 5.

方法：该问题可以基于以下观察来解决。

Minimum count of steps required to visit the block (i₂, j₂) starting from (i₁, j₁) is equal to abs(i₂ – i₁) + abs(j₂ – j₁)

请按照以下步骤解决问题：

• 首先访问使用上述观察值最少步数的角落。
• 通过顺时针或逆时针遍历网格边界来访问网格的其他角，这取决于访问角的最少步数。
• 最后，打印获得的最小步数。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include 
using namespace std;
 
// Function to find the minimum count of steps
// required to visit all the corners of the grid
int min_steps_required(int n, int m, int r, int c)
{
 
    // Stores corner of the grid
    int i, j;
 
    // Stores minimum count of steps required
    // to visit the first corner of the grid
    int corner_steps_req = INT_MAX;
 
    // Checking for leftmost upper corner
    i = 1;
    j = 1;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    // Checking for leftmost down corner
    i = n;
    j = 1;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    // Checking for rigthmost upper corner
    i = 1;
    j = m;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    // Checking for rigthmost down corner
    i = n;
    j = m;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    // Stores minimum count of steps required
    // to visit remaining three corners of the grid
    int minimum_steps = min(2 * (n - 1) + m - 1,
                            2 * (m - 1) + n - 1);
 
    return minimum_steps + corner_steps_req;
}
 
// Driver Code
int main()
{
 
    int n = 3;
    int m = 2;
    int r = 1;
    int c = 1;
 
    cout << min_steps_required(n, m, r, c);
 
    return 0;
}

Java

// Java Program to implement the
// above approach
import java.util.*;
class GFG
{
  
// Function to find the minimum count of steps
// required to visit all the corners of the grid
static int min_steps_required(int n, int m, int r, int c)
{
 
    // Stores corner of the grid
    int i, j;
 
    // Stores minimum count of steps required
    // to visit the first corner of the grid
    int corner_steps_req = Integer.MAX_VALUE;
 
    // Checking for leftmost upper corner
    i = 1;
    j = 1;
    corner_steps_req = Math.min(corner_steps_req,
                           Math.abs(r - i) + Math.abs(j - c));
 
    // Checking for leftmost down corner
    i = n;
    j = 1;
    corner_steps_req = Math.min(corner_steps_req,
                           Math.abs(r - i) + Math.abs(j - c));
 
    // Checking for rigthmost upper corner
    i = 1;
    j = m;
    corner_steps_req = Math.min(corner_steps_req,
                           Math.abs(r - i) + Math.abs(j - c));
 
    // Checking for rigthmost down corner
    i = n;
    j = m;
    corner_steps_req = Math.min(corner_steps_req,
                           Math.abs(r - i) + Math.abs(j - c));
 
    // Stores minimum count of steps required
    // to visit remaining three corners of the grid
    int minimum_steps = Math.min(2 * (n - 1) + m - 1,
                            2 * (m - 1) + n - 1);
 
    return minimum_steps + corner_steps_req;
}
  
// Driver Code
public static void main(String[] args)
{
    int n = 3;
    int m = 2;
    int r = 1;
    int c = 1;
 
    System.out.print(min_steps_required(n, m, r, c));
}
}
 
// This code is contributed by code_hunt.

Python3

# Python3 program to implement
# the above approach
import sys
INT_MAX = sys.maxsize;
 
# Function to find the minimum count of steps
# required to visit all the corners of the grid
def min_steps_required(n, m, r, c) :
 
    # Stores corner of the grid
    i = 0; j = 0;
 
    # Stores minimum count of steps required
    # to visit the first corner of the grid
    corner_steps_req = INT_MAX;
 
    # Checking for leftmost upper corner
    i = 1;
    j = 1;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    # Checking for leftmost down corner
    i = n;
    j = 1;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    # Checking for rigthmost upper corner
    i = 1;
    j = m;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    # Checking for rigthmost down corner
    i = n;
    j = m;
    corner_steps_req = min(corner_steps_req,
                           abs(r - i) + abs(j - c));
 
    # Stores minimum count of steps required
    # to visit remaining three corners of the grid
    minimum_steps = min(2 * (n - 1) + m - 1,
                            2 * (m - 1) + n - 1);
 
    return minimum_steps + corner_steps_req;
 
# Driver Code
if __name__ == "__main__" :
    n = 3;
    m = 2;
    r = 1;
    c = 1;
    print(min_steps_required(n, m, r, c));
 
    # This code is contributed by AnkThon

C#

// C# program to implement the
// above approach
using System;
 
class GFG{
  
// Function to find the minimum count
// of steps required to visit all the
// corners of the grid
static int min_steps_required(int n, int m,
                              int r, int c)
{
     
    // Stores corner of the grid
    int i, j;
 
    // Stores minimum count of steps required
    // to visit the first corner of the grid
    int corner_steps_req = int.MaxValue;
 
    // Checking for leftmost upper corner
    i = 1;
    j = 1;
    corner_steps_req = Math.Min(corner_steps_req,
                                Math.Abs(r - i) +
                                Math.Abs(j - c));
 
    // Checking for leftmost down corner
    i = n;
    j = 1;
    corner_steps_req = Math.Min(corner_steps_req,
                                Math.Abs(r - i) +
                                Math.Abs(j - c));
 
    // Checking for rigthmost upper corner
    i = 1;
    j = m;
    corner_steps_req = Math.Min(corner_steps_req,
                                Math.Abs(r - i) +
                                Math.Abs(j - c));
 
    // Checking for rigthmost down corner
    i = n;
    j = m;
    corner_steps_req = Math.Min(corner_steps_req,
                                Math.Abs(r - i) +
                                Math.Abs(j - c));
 
    // Stores minimum count of steps required
    // to visit remaining three corners of the grid
    int minimum_steps = Math.Min(2 * (n - 1) + m - 1,
                                 2 * (m - 1) + n - 1);
 
    return minimum_steps + corner_steps_req;
}
  
// Driver Code
public static void Main(String[] args)
{
    int n = 3;
    int m = 2;
    int r = 1;
    int c = 1;
 
    Console.Write(min_steps_required(n, m, r, c));
}
}
 
// This code is contributed by shikhasingrajput

Javascript

 
// JavaScript program to implement the
// above approach
  
// Function to find the minimum count
// of steps required to visit all the
// corners of the grid
 
function  min_steps_required( n,  m,  r,  c)
{
      
    // Stores corner of the grid
    var i, j;
  
    // Stores minimum count of steps required
    // to visit the first corner of the grid
     
    var corner_steps_req = Number.MAX_VALUE;
  
    // Checking for leftmost upper corner
     
    i = 1;
    j = 1;
    corner_steps_req = Math.min(corner_steps_req,
                                Math.abs(r - i) +
                                Math.abs(j - c));
  
    // Checking for leftmost down corner
    i = n;
    j = 1;
    corner_steps_req = Math.min(corner_steps_req,
                                Math.abs(r - i) +
                                Math.abs(j - c));
  
    // Checking for rigthmost upper corner
    i = 1;
    j = m;
    corner_steps_req = Math.min(corner_steps_req,
                                Math.abs(r - i) +
                                Math.abs(j - c));
  
    // Checking for rigthmost down corner
    i = n;
    j = m;
    corner_steps_req = Math.min(corner_steps_req,
                                Math.abs(r - i) +
                                Math.abs(j - c));
  
    // Stores minimum count of steps required
    // to visit remaining three corners of the grid
    var minimum_steps = Math.min(2 * (n - 1) + m - 1,
                                 2 * (m - 1) + n - 1);
  
    return minimum_steps + corner_steps_req;
}
   
// Driver Code
 
    var n = 3;
    var m = 2;
    var r = 1;
    var c = 1;
  
    document.write(min_steps_required(n, m, r, c));
     

输出：

4

时间复杂度： O(1)
辅助空间： O(1)