Find the Number of Subsequences With Equal GCD

Find the Number of Subsequences With Equal GCD - Problem

Find the Number of Subsequences With Equal GCD

You are given an integer array nums. Your mission is to find pairs of disjoint subsequences that share a special property: they have the same Greatest Common Divisor (GCD).

Here's what you need to find:
• Two non-empty subsequences seq1 and seq2
• These subsequences must be disjoint (no shared indices from the original array)
• The GCD of all elements in seq1 equals the GCD of all elements in seq2

Count all such valid pairs and return the result modulo 10^9 + 7.

Example: For nums = [1, 2, 3, 4], one valid pair could be seq1 = [2, 4] (GCD = 2) and seq2 = [1, 3] (GCD = 1), but since GCD(2,4) ≠ GCD(1,3), this wouldn't count.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 3, 4]

› Output: 1

💡 Note: One valid pair exists: subsequences [2, 4] and [1, 3]. However, GCD(2,4) = 2 and GCD(1,3) = 1, so they don't have equal GCDs. Actually, we need to find pairs like [2] (GCD=2) and [4] (GCD=4), but these don't have equal GCDs either. The actual valid pair might be single elements with the same GCD.

example_2.py — Equal Elements

$ Input: nums = [2, 2, 2, 2]

› Output: 6

💡 Note: All subsequences have GCD = 2. We can choose any two disjoint non-empty subsequences. For example: [2] from index 0 and [2] from index 1, or [2,2] from indices {0,1} and [2] from index 2, etc.

example_3.py — No Valid Pairs

$ Input: nums = [1, 3]

› Output: 0

💡 Note: We have subsequences [1] (GCD=1) and [3] (GCD=3). Since 1 ≠ 3, there are no valid pairs. We could also have [1,3] (GCD=1), but we need two disjoint subsequences.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
The result should be returned modulo 10⁹ + 7
Subsequences must be non-empty and disjoint

Visualization

Tap to expand

Understanding the Visualization

Identify Musicians

Each array element is a musician with specific harmonic properties

Find Harmony Groups

Group musicians by their possible fundamental frequencies (GCD values)

Count Combinations

Use mathematical techniques to count valid orchestra pairs efficiently

Combine Results

Sum up all possible ways to form two harmonious orchestras

Key Takeaway

🎯 Key Insight: Instead of checking every possible orchestra combination (exponential time), we mathematically count how many orchestras can play each harmony, then combine the counts to find valid pairs in polynomial time!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses Dynamic Programming with Inclusion-Exclusion Principle. Instead of generating all subsequences explicitly, we count subsequences by their GCD values efficiently. For each possible GCD value g, we count elements divisible by g, compute total subsequences using 2^count - 1, then apply inclusion-exclusion to get exact counts. Finally, we use combinatorics to count valid disjoint pairs for each GCD.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Inclusion-Exclusion (Optimal)	O(n × max_val × log(max_val))	O(max_val)	Use DP to count subsequences by GCD, then apply inclusion-exclusion principle
Brute Force (Generate All Subsequences)	O(4^n * n)	O(2^n * n)	Generate all possible pairs of disjoint subsequences and check GCD equality

Dynamic Programming with Inclusion-Exclusion (Optimal) — Algorithm Steps

Find all possible GCD values (divisors of array elements)
Use DP to count subsequences for each possible GCD
Apply inclusion-exclusion to get exact counts for each GCD
For each GCD g with count[g] subsequences, calculate pairs using combinatorics
Sum up all valid pairs and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Divisors

For each element, mark all its divisors as potential GCDs

Count by Divisibility

Count how many elements are divisible by each potential GCD

Apply Inclusion-Exclusion

Calculate exact counts using mathematical principle

Combine Pairs

Use combinatorics to count valid disjoint pairs

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MOD 1000000007

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

int countSubsequencesWithEqualGCD(int* nums, int n) {
    if (n < 2) return 0;
    
    int maxVal = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    int* divisibleCount = calloc(maxVal + 1, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        for (int d = 1; d * d <= num; d++) {
            if (num % d == 0) {
                divisibleCount[d]++;
                if (d != num / d) {
                    divisibleCount[num / d]++;
                }
            }
        }
    }
    
    long long* dp = calloc(maxVal + 1, sizeof(long long));
    
    for (int g = maxVal; g >= 1; g--) {
        if (divisibleCount[g] > 0) {
            long long totalSubseq = (modPow(2, divisibleCount[g], MOD) - 1 + MOD) % MOD;
            dp[g] = totalSubseq;
            
            for (int multiple = 2 * g; multiple <= maxVal; multiple += g) {
                dp[g] = (dp[g] - dp[multiple] + MOD) % MOD;
            }
        }
    }
    
    long long result = 0;
    
    for (int g = 1; g <= maxVal; g++) {
        if (divisibleCount[g] >= 2 && dp[g] > 0) {
            long long ways = (dp[g] * (dp[g] - 1) / 2) % MOD;
            result = (result + ways) % MOD;
        }
    }
    
    free(divisibleCount);
    free(dp);
    
    return (int)result;
}

int main() {
    int nums[] = {1, 2, 3, 4};
    int n = 4;
    printf("%d\n", countSubsequencesWithEqualGCD(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_val × log(max_val))

n elements, max_val possible GCD values, log factor for GCD calculations and divisor enumeration

⚡ Linearithmic

Space Complexity

O(max_val)

Space to store DP arrays for each possible GCD value

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Inclusion-Exclusion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler