 Open in App
Not now

# Count subsequences with GCD equal to X

• Last Updated : 05 Oct, 2021

Given an array arr[] consisting of N integers and a positive integer X, the task is to count subsequences with GCD exactly X.

Examples:

Input: arr[] = {6, 4, 30}  X = 2
Output: 3
Explanation: Subsequences with GCD(=2) are { {6, 4, 30}, {4, 30}, {6, 4} }. Hence, 3 is the answer.

Input: arr[] = {6, 6, 6}  X = 3
Output: 0

Approach: The given problem can be solved with the help of Dynamic Programming. Follow the steps below to solve the given problem.

• Define a 2-D dp table dp[i][j] which will denote the number of valid subsequences till index i with GCD(= j).
• For each iteration we have 2 choices:
• Take the current element: The dp table can be updated as dp[i + 1][gcd(j, arr[i])] += dp[i][j].
• Skip the current element: The dp table can be updated as dp[i+1][j] += dp[i][j].
• The base case is dp = 1.
• Since the gcd of two numbers can never be greater than the two numbers, so the values of j will be up to the maximum element in the array. Therefore,  it can be solved iteratively and the final answer will be dp[N][X].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the total subsequences``// having GCD = X``int` `totalValidSubsequences(``    ``vector<``int``> arr, ``int` `X, ``int` `N)``{``    ``// Find the maximum element of``    ``// the array``    ``int` `mx = *max_element(``        ``arr.begin(), arr.end());` `    ``// Check if X is greater than mx``    ``if` `(X > mx) {``        ``return` `0;``    ``}``    ``// Make a 2-d dp table of``    ``// size [n+1, mx + 1]``    ``vector > dp(``        ``N + 1, vector<``int``>(mx + 1, 0));` `    ``// Base Case``    ``dp = 1;` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Iterate through all possible``        ``// indexes``        ``for` `(``int` `j = 0; j <= mx; j++) {` `            ``// Iterate through all``            ``// possible values` `            ``// Case 1. Skip the element``            ``dp[i + 1][j] += dp[i][j];` `            ``// Case 2. Skip the current element``            ``dp[i + 1][__gcd(j, arr[i])] += dp[i][j];``        ``}``    ``}` `    ``// Return the answer dp[N][X]``    ``return` `dp[N][X];``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 6, 4, 30 };``    ``int` `X = 2;``    ``int` `N = arr.size();``    ``cout << totalValidSubsequences(arr, X, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG {``      ` `       ``// Function to find maximum in arr[]``     ``static` `int` `max(``int``[] arr)``     ``{``           ` `         ``// Initialize maximum element``         ``int` `max = arr[``0``];``        ` `         ``// Traverse array elements from second and``         ``// compare every element with current max ``         ``for` `(``int` `i = ``1``; i < arr.length; i++)``             ``if` `(arr[i] > max)``                 ``max = arr[i];``        ` `         ``return` `max;``     ``}``  ` `      ``// Recursive function to return gcd of a and b``      ``static` `int` `gcd(``int` `a, ``int` `b)``    ``{``      ``if` `(b == ``0``)``        ``return` `a;``      ``return` `gcd(b, a % b);``    ``}` `    ``// Function to find the total subsequences``    ``// having GCD = X``    ``static` `int` `totalValidSubsequences(``int``[] arr,``                                      ``int` `X, ``int` `N)``    ``{``        ``// Find the maximum element of``        ``// the array``        ``int` `mx = max(arr);` `        ``// Check if X is greater than mx``        ``if` `(X > mx) {``            ``return` `0``;``        ``}``        ``// Make a 2-d dp table of``        ``// size [n+1, mx + 1]``        ``int` `dp[][] = ``new` `int``[N + ``1``][mx + ``1``];` `        ``// Base Case``        ``dp[``0``][``0``] = ``1``;` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// Iterate through all possible``            ``// indexes``            ``for` `(``int` `j = ``0``; j <= mx; j++) {` `                ``// Iterate through all``                ``// possible values` `                ``// Case 1. Skip the element``                ``dp[i + ``1``][j] += dp[i][j];` `                ``// Case 2. Skip the current element``                ``dp[i + ``1``][gcd(j, arr[i])] += dp[i][j];``            ``}``        ``}` `        ``// Return the answer dp[N][X]``        ``return` `dp[N][X];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``6``, ``4``, ``30` `};``           ``int` `X = ``2``;``        ``int` `N = arr.length;``           ``System.out.println(totalValidSubsequences(arr, X, N));``    ``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python 3 program for the above approach``from` `math ``import` `gcd` `# Function to find the total subsequences``# having GCD = X``def` `totalValidSubsequences(arr, X, N):``  ` `    ``# Find the maximum element of``    ``# the array``    ``mx ``=` `max``(arr)` `    ``# Check if X is greater than mx``    ``if` `(X > mx):``        ``return` `0``    ``# Make a 2-d dp table of``    ``# size [n+1, mx + 1]``    ``dp ``=` `[[``0` `for` `i ``in` `range``(mx``+``1``)] ``for` `j ``in` `range``(N ``+` `1``)]` `    ``# Base Case``    ``dp[``0``][``0``] ``=` `1` `    ``for` `i ``in` `range``(N):``      ` `        ``# Iterate through all possible``        ``# indexes``        ``for` `j ``in` `range``(mx``+``1``):``          ` `            ``# Iterate through all``            ``# possible values` `            ``# Case 1. Skip the element``            ``dp[i ``+` `1``][j] ``+``=` `dp[i][j]` `            ``# Case 2. Skip the current element``            ``dp[i ``+` `1``][gcd(j, arr[i])] ``+``=` `dp[i][j]` `    ``# Return the answer dp[N][X]``    ``return` `dp[N][X]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``6``, ``4``, ``30``]``    ``X ``=` `2``    ``N ``=` `len``(arr)``    ``print``(totalValidSubsequences(arr, X, N))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `       ``// Function to find maximum in arr[]``static` `int` `max(``int` `[]arr)``{``  ` `  ``// Initialize maximum element``  ``int` `max = arr;``  ` `  ``// Traverse array elements from second and``  ``// compare every element with current max ``  ``for` `(``int` `i = 1; i < arr.Length; i++)``             ``if` `(arr[i] > max)``                 ``max = arr[i];``        ` `         ``return` `max;``}`  `// Recursive function to return gcd of a and b``static` `int` `gcd(``int` `a, ``int` `b)``{`` ``if` `(b == 0)``        ``return` `a;``      ``return` `gcd(b, a % b);``}`  `// Function to find the total subsequences``// having GCD = X``static` `int` `totalValidSubsequences(``int``[] arr,``                                      ``int` `X, ``int` `N)``    ``{``        ``// Find the maximum element of``        ``// the array``        ``int` `mx = max(arr);` `        ``// Check if X is greater than mx``        ``if` `(X > mx) {``            ``return` `0;``        ``}``        ``// Make a 2-d dp table of``        ``// size [n+1, mx + 1]``        ``int``[,] dp = ``new` `int``[N + 1, mx + 1];` `        ``// Base Case``        ``dp[0, 0] = 1;` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``// Iterate through all possible``            ``// indexes``            ``for` `(``int` `j = 0; j <= mx; j++) {` `                ``// Iterate through all``                ``// possible values` `                ``// Case 1. Skip the element``                ``dp[i + 1, j] += dp[i, j];` `                ``// Case 2. Skip the current element``                ``dp[i + 1, gcd(j, arr[i])] += dp[i, j];``            ``}``        ``}` `        ``// Return the answer dp[N][X]``        ``return` `dp[N, X];``    ``}`   `// Driver Code``public` `static` `void` `Main()``{``   ``int``[] arr = { 6, 4, 30 };``           ``int` `X = 2;``        ``int` `N = arr.Length;``           ``Console.Write(totalValidSubsequences(arr, X, N));``}``}` `// This code is contributed by _saurabh_jaiswal`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N*M), where M is the maximum element of the array.
Auxiliary Space: O(N*M)

My Personal Notes arrow_drop_up