给定两个算术序列中的最小公有元素

给定四个正数A，B，C，D ，使得A和B分别是第一项和第一算术序列的共同差，而C和D分别代表第二个算术序列，如下所示：

First Arithmetic Sequence: A, A + B, A + 2B, A + 3B, ……. 
Second Arithmetic Sequence: C, C + D, C + 2D, C + 3D, ……. 
 

任务是从上述AP序列中找到最不常见的元素。如果不存在这样的数字，则打印-1 。

例子：

Input: A = 2, B = 20, C = 19, D = 9 
Output: 82 
Explanation: 
Sequence 1: {2, 2 + 20, 2 + 2(20), 2 + 3(20), 2 + 4(20), …..} = {2, 22, 42, 62, 82, …..} 
Sequence 2: {19, 19 + 9, 19 + 2(9), 19 + 3(9), 19 + 4(9), 19 + 5(9), 19 + 6(9), 19 + 7(9) …..} = {19, 28, 37, 46, 55, 64, 73, 82, …..} 
Therefore, 82 is the smallest common element.

 

Input: A = 2, B = 18, C = 19, D = 9 
Output: -1

 

方法：

由于给定两个序列的任何一项都可以表示为A + x * B和C + y * D ，因此，要解决此问题，我们需要找到两个项相等的x和y的最小值。
请按照以下步骤解决问题：

• 为了找到两个AP序列中共有的最小值，该想法是找到满足以下方程式的x和y的最小整数值：

A + x*B = C + y*D

=> The above equation can be rearranged as 
x*B = C – A + y*D
=> The above equation can be further rearranged as 
x = (C – A + y*D) / B 
 

• 检查是否存在任何整数值y ，以使(C – A + y * D)％B为0 。如果存在，则最小的数字为(C + y * D) 。
• 检查(C + y * D)是否为答案，其中y处于(0，B)范围内，因为从i = B，B + 1， …。其余的值将重复。
• 如果从上述步骤中没有得到这样的数字，则打印-1 。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to find the smallest element
// common in both the subsequences
long smallestCommon(long a, long b,
                    long c, long d)
{
    // If a is equal to c
    if (a == c)
        return a;
 
    // If a exceeds c
    if (a > c) {
        swap(a, c);
        swap(b, d);
    }
 
    long first_term_diff = (c - a);
    long possible_y;
 
    // Check for the satisfying
    // equation
    for (possible_y = 0; possible_y < b; possible_y++) {
 
        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b
             + possible_y * d)
                % b
            == 0) {
            break;
        }
    }
 
    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b) {
        return c + possible_y * d;
    }
 
    // If no value of possible_y
    // satisfies the given equation
    return -1;
}
 
// Driver Code
int main()
{
    long A = 2, B = 20, C = 19, D = 9;
    cout << smallestCommon(A, B, C, D);
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to find the smallest element
// common in both the subsequences
static int smallestCommon(int a, int b,
                          int c, int d)
{
    // If a is equal to c
    if (a == c)
        return a;
 
    // If a exceeds c
    if (a > c)
    {
        swap(a, c);
        swap(b, d);
    }
 
    int first_term_diff = (c - a);
    int possible_y;
 
    // Check for the satisfying
    // equation
    for (possible_y = 0;
         possible_y < b; possible_y++)
    {
 
        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0)
        {
            break;
        }
    }
 
    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b)
    {
        return c + possible_y * d;
    }
 
    // If no value of possible_y
    // satisfies the given equation
    return -1;
}
   
static void swap(int x, int y)
{
      int temp = x;
      x = y;
      y = temp;
}
   
// Driver Code
public static void main(String[] args)
{
    int A = 2, B = 20, C = 19, D = 9;
    System.out.print(smallestCommon(A, B, C, D));
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 program to implement
# the above approach
 
# Function to find the smallest element
# common in both the subsequences
def smallestCommon(a, b, c, d):
   
    # If a is equal to c
    if (a == c):
        return a;
 
    # If a exceeds c
    if (a > c):
        swap(a, c);
        swap(b, d);
 
    first_term_diff = (c - a);
    possible_y = 0;
 
    # Check for the satisfying
    # equation
    for possible_y in range(b):
 
        # Least value of possible_y
        # satisfying the given equation
        # will yield True in the below if
        # and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0):
            break;
 
    # If the value of possible_y
    # satisfying the given equation
    # lies in range [0, b]
    if (possible_y != b):
        return c + possible_y * d;
 
    # If no value of possible_y
    # satisfies the given equation
    return -1;
 
def swap(x, y):
    temp = x;
    x = y;
    y = temp;
 
# Driver Code
if __name__ == '__main__':
    A = 2; B = 20; C = 19; D = 9;
    print(smallestCommon(A, B, C, D));
 
# This code is contributed by Rajput-Ji

C#

// C# program to implement
// the above approach
using System;
class GFG{
    
// Function to find the smallest element
// common in both the subsequences
static int smallestCommon(int a, int b,
                          int c, int d)
{
    // If a is equal to c
    if (a == c)
        return a;
 
    // If a exceeds c
    if (a > c)
    {
        swap(a, c);
        swap(b, d);
    }
 
    int first_term_diff = (c - a);
    int possible_y;
 
    // Check for the satisfying
    // equation
    for (possible_y = 0;
         possible_y < b; possible_y++)
    {
 
        // Least value of possible_y
        // satisfying the given equation
        // will yield true in the below if
        // and break the loop
        if ((first_term_diff % b +
             possible_y * d) % b == 0)
        {
            break;
        }
    }
 
    // If the value of possible_y
    // satisfying the given equation
    // lies in range [0, b]
    if (possible_y != b)
    {
        return c + possible_y * d;
    }
 
    // If no value of possible_y
    // satisfies the given equation
    return -1;
}
   
static void swap(int x, int y)
{
      int temp = x;
      x = y;
      y = temp;
}
   
// Driver Code
public static void Main(String[] args)
{
    int A = 2, B = 20, C = 19, D = 9;
    Console.Write(smallestCommon(A, B, C, D));
}
}
 
 
// This code is contributed by Rajput-Ji

输出：

82

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