通过增加一个或两个 K 来最小化将 (0, 0) 转换为 (N, M) 的操作

给定两个整数N和M ，任务是使用以下操作计算将(0, 0)转换为(N, M)所需的最小操作数：

• 选择任何整数K并将(x, y)转换为(x + K, y + K) 。
• 选择任何整数K并将(x, y)转换为(x – K, y + K) 或 (x + K, y – K) 。

例子：

Input: N = 3, M = 5
Output: 2
Explanation: In 1st operation, take K = 4, and perform 1st operation i.e, (0 + 4, 0 + 4) -> (4, 4). In 2nd operation, take K = 1 and perform 2nd operation i.e, (4 – 1, 4 + 1) -> (3, 5) which is the required value. 

Input: N = 1, M = 4
Output: -1
Explanation: No possible sequence of given operations exists to convert (0, 0) to (1, 4). 

方法：给定的问题可以通过观察每个（N，M）对可以分为以下四种情况来解决：

• 情况 1，其中 (N, M) = (0, 0)。在这种情况下，将需要 0 次操作。
• 情况 2，其中 N = M。在这种情况下，选择 K = N 并执行第一个操作。因此只需要一项操作。
• 情况 3，其中 N 和 M 具有相同的奇偶性，即 N % 2 = M % 2。在这种情况下，可以观察到所需的操作数始终为 2。
• 情况 4，其中 N 和 M 具有不同的奇偶性，即 N % 2 != M % 2。在这种情况下，不存在可能的操作序列。

下面是上述方法的实现：

C++

// C++ program of the above approach
#include 
using namespace std;
 
// Function to find the minimum number
// of operations required to convert
// a pair of integers (0, 0) to (N, M)
int minOperations(int N, int M)
{
    // Case 1
    if (N == M && N == 0)
        return 0;
 
    // Case 2
    if (N == M)
        return 1;
 
    // Case 3
    if (N % 2 == M % 2)
        return 2;
 
    // Not possible
    return -1;
}
 
// Driver Code
int main()
{
    int N = 3;
    int M = 5;
    cout << minOperations(N, M);
 
    return 0;
}

Java

// Java program to implement
// the above approach
class GFG {
 
  // Function to find the minimum number
  // of operations required to convert
  // a pair of integers (0, 0) to (N, M)
  static int minOperations(int N, int M) {
 
    // Case 1
    if (N == M && N == 0)
      return 0;
 
    // Case 2
    if (N == M)
      return 1;
 
    // Case 3
    if (N % 2 == M % 2)
      return 2;
 
    // Not possible
    return -1;
  }
 
  // Driver Code
  public static void main(String args[])
  {
    int N = 3;
    int M = 5;
    System.out.println(minOperations(N, M));
 
  }
}
 
// This code is contributed by Saurabh Jaiswal

Python3

# Python program of the above approach
 
# Function to find the minimum number
# of operations required to convert
# a pair of integers (0, 0) to (N, M)
def minOperations(N, M):
   
    # Case 1
    if N == M and N == 0:
        return 0
 
    # Case 2
    if N == M:
        return 1
 
    # Case 3
    if N % 2 == M % 2:
        return 2
 
    # Not possible
    return -1
 
# Driver Code
N = 3
M = 5
print(minOperations(N, M))
 
# This code is contributed by GFGking

C#

// C# program to implement
// the above approach
using System;
class GFG
{
 
  // Function to find the minimum number
  // of operations required to convert
  // a pair of integers (0, 0) to (N, M)
  static int minOperations(int N, int M)
  {
     
    // Case 1
    if (N == M && N == 0)
      return 0;
 
    // Case 2
    if (N == M)
      return 1;
 
    // Case 3
    if (N % 2 == M % 2)
      return 2;
 
    // Not possible
    return -1;
  }
 
  // Driver Code
  public static void Main()
  {
    int N = 3;
    int M = 5;
    Console.Write(minOperations(N, M));
 
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

    // JavaScript program of the above approach
 
    // Function to find the minimum number
    // of operations required to convert
    // a pair of integers (0, 0) to (N, M)
    const minOperations = (N, M) => {
        // Case 1
        if (N == M && N == 0)
            return 0;
 
        // Case 2
        if (N == M)
            return 1;
 
        // Case 3
        if (N % 2 == M % 2)
            return 2;
 
        // Not possible
        return -1;
    }
 
    // Driver Code
    let N = 3;
    let M = 5;
    document.write(minOperations(N, M));
 
// This code is contributed by rakeshsahni
 

输出

2

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