Number of elements from the array which are reachable after performing given operations on D

Given an array arr[] and three integers D, A and B. You start with the number D and at any time you can add or subtract either A or B to the current number. That means you can do the following four operations any number of times:

  1. Add A to the current number.
  2. Subtract A from the current number.
  3. Add B to the current number.
  4. Subtract B from the current number.

The task is to find the count of integers from the given array which can be reached after performing the above operations.

Examples:



Input: arr[] = {4, 5, 6, 7, 8, 9}, D = 4, A = 4, B = 6
Output: 3
The reachable numbers are:
4 = 4
6 = 4 + 6 – 4
8 = 4 + 4

Input: arr[] = {24, 53, 126, 547, 48, 97}, D = 2, A = 5, B = 8
Output: 6

Approach: This problem can be solved using a property of diophantine equations

Let the integer we want to reach from the array be x. If we start with D and we can add/subtract A or B to it any number of times, that means we need to find if the following equation has integer solution or not.

D + p * A + q * B = x

If it has integer solutions in p and q then it means we can reach the integer x from D otherwise not.
Rearrange this equation to

p * A + q * B = x – D

This equation has an integer solution if and only if (x – D) % GCD(A, B) = 0.

Now iterate over the integers in the array and check if this equation has a solution or not for the current x.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the GCD
// of a and b
int GCD(int a, int b)
{
    if (b == 0)
        return a;
    return GCD(b, a % b);
}
  
// Function to return the count of reachable
// integers from the given array
int findReachable(int arr[], int D, int A,
                  int B, int n)
{
  
    // GCD of A and B
    int gcd_AB = GCD(A, B);
  
    // To store the count of reachable integers
    int count = 0;
    for (int i = 0; i < n; i++) {
  
        // If current element can be reached
        if ((arr[i] - D) % gcd_AB == 0)
            count++;
    }
  
    // Return the count
    return count;
}
  
// Driver code
int main()
{
    int arr[] = { 4, 5, 6, 7, 8, 9 };
    int n = sizeof(arr) / sizeof(int);
    int D = 4, A = 4, B = 6;
  
    cout << findReachable(arr, D, A, B, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
{
  
    // Function to return the GCD
    // of a and b
    static int GCD(int a, int b)
    {
        if (b == 0)
            return a;
        return GCD(b, a % b);
    }
  
    // Function to return the count of reachable
    // integers from the given array
    static int findReachable(int[] arr, int D, int A,
                    int B, int n)
    {
  
        // GCD of A and B
        int gcd_AB = GCD(A, B);
  
        // To store the count of reachable integers
        int count = 0;
        for (int i = 0; i < n; i++) 
        {
  
            // If current element can be reached
            if ((arr[i] - D) % gcd_AB == 0)
                count++;
        }
  
        // Return the count
        return count;
    }
  
    // Driver code
    public static void main(String[] args) 
    {
  
        int arr[] = { 4, 5, 6, 7, 8, 9 };
        int n = arr.length;
        int D = 4, A = 4, B = 6;
  
        System.out.println(findReachable(arr, D, A, B, n));
  
    }
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of the approach
  
# Function to return the GCD
# of a and b
def GCD(a, b):
    if (b == 0):
        return a;
    return GCD(b, a % b);
  
  
# Function to return the count of reachable
# integers from the given array
def findReachable(arr, D, A, B, n):
  
    # GCD of A and B
    gcd_AB = GCD(A, B);
  
    # To store the count of reachable integers
    count = 0;
    for i in range(n):
  
        # If current element can be reached
        if ((arr[i] - D) % gcd_AB == 0):
            count+=1;
  
    # Return the count
    return count;
  
# Driver code
arr = [ 4, 5, 6, 7, 8, 9 ];
n = len(arr);
D = 4; A = 4; B = 6;
  
print(findReachable(arr, D, A, B, n));
  
# This code is contributed by 29AjayKumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG 
  
    // Function to return the GCD 
    // of a and b 
    static int GCD(int a, int b) 
    
        if (b == 0) 
            return a; 
        return GCD(b, a % b); 
    
  
    // Function to return the count of reachable 
    // integers from the given array 
    static int findReachable(int[] arr, int D, int A, 
                    int B, int n) 
    
  
        // GCD of A and B 
        int gcd_AB = GCD(A, B); 
  
        // To store the count of reachable integers 
        int count = 0; 
        for (int i = 0; i < n; i++) 
        
  
            // If current element can be reached 
            if ((arr[i] - D) % gcd_AB == 0) 
                count++; 
        
  
        // Return the count 
        return count; 
    
  
    // Driver code 
    public static void Main() 
    
  
        int []arr = { 4, 5, 6, 7, 8, 9 }; 
        int n = arr.Length; 
        int D = 4, A = 4, B = 6; 
  
        Console.WriteLine(findReachable(arr, D, A, B, n)); 
  
    
  
// This code is contributed by AnkitRai01

chevron_right


Output:

3


My Personal Notes arrow_drop_up

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.