执行某些操作后可从D派生的数组元素数

给定一个由N个整数和3个整数D，A和B组成的数组。任务是通过对D执行以下操作来查找可以将D转换为的数组元素的数量：

• 加A(+ A)
• 减法A(-A)
• 加B(+ B)
• 减法B(-B)

注意：允许执行任何数量的任何类型的操作。
例子：

Input :  arr = {1, 2, 3}, D = 6, A = 3, B = 2 
Output :  3
Explanation: 
We can derive 1 from D by performing (6 - 3(A) - 2(B))
We can derive 2 from D by performing (6 - 2(A) - 2(A))
We can derive 3 from D by performing (6 - 3(A))
Thus, All array elements can be derived from D.
 
Input :  arr = {1, 2, 3}, D = 7, A = 4, B = 2 
Output :  2
Explanation: 
We can derive 1 from D by performing (7 - 4(A) - 2(B))
We can derive 3 from D by performing (7 - 4(A))
Thus, we can derive {1, 3}

假设我们要检查元素a _i是否可以从D派生：
假设我们执行：

• type1(即加A)的操作P次。
• 类型2的运算(即，减去A)Q次。
• 类型3(即加B)的操作R次。
• 类型4(即减法B)的运算S次。

Let the value we get after performing these operations be X, then, 
-> X = P*A – Q*A + R*B – S*B 
-> X = (P – Q) * A + (R – S) * B
Suppose we successfully derive A_i from D, i.e X = |A_i – D|, 
-> |A_i – D| = (P – Q) * A + (R – S) * B
Let (P – Q) = some constant say, U 
and similarly let (R – S) be a constant, V
-> |A_i – D| = U * A + V * B
This is in the form of the Linear Diophantine Equation and the solution exists only when |A_i – D| is divisible by gcd(A, B). 
 

因此，现在我们可以简单地遍历数组并计算| A _i – D |的所有此类A _i 。可被gcd(a，b)整除。
下面是上述方法的实现：

C++

// CPP program to find the number of array elements
// which can be derived by perming (+A, -A, +B, -B)
// operations on D
#include 
 
using namespace std;
 
// Function to return
// gcd of a and b
int gcd(int a, int b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}
 
/* Function to Return the number of elements
   of arr[] which can be derived from D by
   performing (+A, -A, +B, -B) */
int findPossibleDerivables(int arr[], int n, int D,
                                      int A, int B)
{
    // find the gcd of A and B
    int gcdAB = gcd(A, B);
 
    // counter stores the number of
    // array elements which
    // can be derived from D
    int counter = 0;
 
    for (int i = 0; i < n; i++) {
        // arr[i] can be derived from D only if
        // |arr[i] - D| is divisible by gcd of A and B
        if ((abs(arr[i] - D) % gcdAB) == 0) {
            counter++;
        }
    }
 
    return counter;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 7, 13 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int D = 5, A = 4, B = 2;
    cout << findPossibleDerivables(arr, n, D, A, B) <<"\n";
 
    int a[] = { 1, 2, 3 };
    n = sizeof(a) / sizeof(a[0]);
    D = 6, A = 3, B = 2;
    cout << findPossibleDerivables(a, n, D, A, B) <<"\n";
 
    return 0;
}

Java

// Java  program to find the number of array elements
// which can be derived by perming (+A, -A, +B, -B)
// operations on D
 
import java.io.*;
 
class GFG {
     
 
 
// Function to return
// gcd of a and b
 static int gcd(int a, int b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}
 
/* Function to Return the number of elements
of arr[] which can be derived from D by
performing (+A, -A, +B, -B) */
static int findPossibleDerivables(int arr[], int n, int D,
                                    int A, int B)
{
    // find the gcd of A and B
    int gcdAB = gcd(A, B);
 
    // counter stores the number of
    // array elements which
    // can be derived from D
    int counter = 0;
 
    for (int i = 0; i < n; i++) {
        // arr[i] can be derived from D only if
        // |arr[i] - D| is divisible by gcd of A and B
        if ((Math.abs(arr[i] - D) % gcdAB) == 0) {
            counter++;
        }
    }
 
    return counter;
}
 
// Driver Code
 
    public static void main (String[] args) {
            int arr[] = { 1, 2, 3, 4, 7, 13 };
    int n = arr.length;
    int D = 5, A = 4, B = 2;
    System.out.println( findPossibleDerivables(arr, n, D, A, B));
 
    int a[] = { 1, 2, 3 };
    n = a.length;
    D = 6;
    A = 3;
    B = 2;
    System.out.println( findPossibleDerivables(a, n, D, A, B));
    }
}
// This code is contributed by anuj_67..

Python3

# Python3 program to find the number of array
# elements which can be derived by perming
# (+A, -A, +B, -B) operations on D
 
# Function to return gcd of a and b
def gcd(a, b) :
     
    if (a == 0) :
        return b
         
    return gcd(b % a, a);
 
""" Function to Return the number of elements
of arr[] which can be derived from D by
performing (+A, -A, +B, -B) """
def findPossibleDerivables(arr, n, D, A, B) :
 
    # find the gcd of A and B
    gcdAB = gcd(A, B)
     
    # counter stores the number of
    # array elements which
    # can be derived from D
    counter = 0
 
    for i in range(n) :
         
        # arr[i] can be derived from D only
        # if |arr[i] - D| is divisible by
        # gcd of A and B
        if ((abs(arr[i] - D) % gcdAB) == 0) :
            counter += 1
 
    return counter
 
# Driver Code
if __name__ == "__main__" :
     
    arr = [ 1, 2, 3, 4, 7, 13 ]
    n = len(arr)
    D, A, B = 5, 4, 2
     
    print(findPossibleDerivables(arr, n, D, A, B))
 
    a = [ 1, 2, 3 ]
    n = len(a)
    D, A, B = 6, 3, 2
     
    print(findPossibleDerivables(a, n, D, A, B))
 
# This code is contributed by Ryuga

C#

// C# program to find the number of array elements
// which can be derived by perming (+A, -A, +B, -B)
// operations on D
using System;   
public class GFG {
 
    // Function to return
    // gcd of a and b
     static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
 
    /* Function to Return the number of elements
    of arr[] which can be derived from D by
    performing (+A, -A, +B, -B) */
    static int findPossibleDerivables(int []arr, int n, int D,
                                        int A, int B)
    {
        // find the gcd of A and B
        int gcdAB = gcd(A, B);
 
        // counter stores the number of
        // array elements which
        // can be derived from D
        int counter = 0;
 
        for (int i = 0; i < n; i++) {
            // arr[i] can be derived from D only if
            // |arr[i] - D| is divisible by gcd of A and B
            if ((Math.Abs(arr[i] - D) % gcdAB) == 0) {
                counter++;
            }
        }
 
        return counter;
    }
 
    // Driver Code
  
    public static void Main () {
            int []arr = { 1, 2, 3, 4, 7, 13 };
    int n = arr.Length;
    int D = 5, A = 4, B = 2;
    Console.WriteLine( findPossibleDerivables(arr, n, D, A, B));
  
    int []a = { 1, 2, 3 };
    n = a.Length;
    D = 6;
    A = 3;
    B = 2;
    Console.WriteLine( findPossibleDerivables(a, n, D, A, B));
    }
}
// This code is contributed by 29AjayKumar

Javascript

// javascript  program to find the number of array elements
// which can be derived by perming (+A, -A, +B, -B)
// operations on D   
 
// Function to return
    // gcd of a and b
    function gcd(a , b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
 
    /*
     * Function to Return the number of elements of arr which can be derived from
     * D by performing (+A, -A, +B, -B)
     */
    function findPossibleDerivables(arr , n , D , A , B) {
        // find the gcd of A and B
        var gcdAB = gcd(A, B);
 
        // counter stores the number of
        // array elements which
        // can be derived from D
        var counter = 0;
 
        for (i = 0; i < n; i++)
        {
         
            // arr[i] can be derived from D only if
            // |arr[i] - D| is divisible by gcd of A and B
            if ((Math.abs(arr[i] - D) % gcdAB) == 0) {
                counter++;
            }
        }
 
        return counter;
    }
 
    // Driver Code
        var arr = [ 1, 2, 3, 4, 7, 13 ];
        var n = arr.length;
        var D = 5, A = 4, B = 2;
        document.write(findPossibleDerivables(arr, n, D, A, B)+"<br/>");
 
        var a = [ 1, 2, 3 ];
        n = a.length;
        D = 6;
        A = 3;
        B = 2;
        document.write(findPossibleDerivables(a, n, D, A, B));
 
// This code is contributed by todaysgaurav.

输出：

4
3

时间复杂度： O(N)，其中N是数组元素的数量。

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。