Count of all possible pairs of disjoint subsets of integers from 1 to N

Given an integer N. Consider the set of first N natural numbers A = {1, 2, 3, …, N}. Let M and P be two non-empty subsets of A. The task is to count the number of unordered pairs of (M, P) such that M and P are disjoint sets. Note that the order of M and P doesn’t matter.

Examples:

Input: N = 3
Output: 6
The unordered pairs are ({1}, {2}), ({1}, {3}),
({2}, {3}), ({1}, {2, 3}), ({2}, {1, 3}), ({3}, {1, 2}).

Input: N = 2
Output: 1

Input: N = 10
Output: 28501

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

Lets assume there are only 6 elements in the set {1, 2, 3, 4, 5, 6}.
When you count the number of subsets with 1 as one of the element of first subset, it comes out to be 211.
Counting number of subsets with 2 being one of the element of first subset, it comes out to be 65, because 1’s not included as order of sets doesn’t matter.
Counting number of subset with 3 being one of the element of first set it comes out to be 65, here a pattern can be observed.
Pattern:

5 = 3 * 1 + 2
19 = 3 * 5 + 4
65 = 3 * 19 + 8
211 = 3 * 65 + 16
S(n) = 3 * S(n-1) + 2^{(n – 2)}
Expanding it until n->2 (means numbers of elements n-2+1=n-1)
2^(n-2) * 3⁽⁰⁾ + 2^{(n – 3)} * 3¹ + 2^{(n – 4)} * 3² + 2^{(n – 5)} * 3³ + … + 2⁽⁰⁾ * 3^{(n – 2)}
From Geometric progression, a + a * r⁰ + a * r¹ + … + a * r^{(n – 1)} = a * (rⁿ – 1) / (r – 1)
S(n) = 3^{(n – 1)} – 2^{(n – 1)}. Remember S(n) is number of subsets with 1 as a one of the elements of first subset but to get the required result, Denoted by T(n) = S(1) + S(2) + S(3) + … +S(n)
It also forms a Geometric progression, so we calculate it by formula of sum of GP
T(n) = (3ⁿ – 2^{n + 1} + 1)/2

As we require T(n) % p where p = 10⁹ + 7
We have to use Fermats’s little theorem
a^-1 = a^{(m – 2)} (mod m) for modular division

Below is the implementation of the above approach:

C++

// C++ implementation of the approach 
  
#include <bits/stdc++.h> 
using namespace std; 
#define p 1000000007 
  
// Modulo exponentiation function 
long long power(long long x, long long y) 
{ 
    // Function to calculate (x^y)%p in O(log(y)) 
    long long res = 1; 
    x = x % p; 
  
    while (y > 0) { 
        if (y & 1) 
            res = (res * x) % p; 
        y = y >> 1; 
        x = (x * x) % p; 
    } 
  
    return res % p; 
} 
  
// Driver function 
int main() 
{ 
    long long n = 3; 
  
    // Evaluating ((3^n-2^(n+1)+1)/2)%p 
    long long x = (power(3, n) % p + 1) % p; 
  
    x = (x - power(2, n + 1) + p) % p; 
  
    // From  Fermats’s little theorem 
    // a^-1 ? a^(m-2) (mod m) 
  
    x = (x * power(2, p - 2)) % p; 
    cout << x << "\n"; 
} 

Java

// Java implementation of the approach 
class GFG  
{  
static int p = 1000000007; 
  
// Modulo exponentiation function 
static long power(long x, long y) 
{ 
    // Function to calculate (x^y)%p in O(log(y)) 
    long res = 1; 
    x = x % p; 
  
    while (y > 0) 
    { 
        if (y % 2 == 1) 
            res = (res * x) % p; 
        y = y >> 1; 
        x = (x * x) % p; 
    } 
    return res % p; 
} 
  
// Driver Code 
public static void main(String[] args)  
{ 
    long n = 3; 
  
    // Evaluating ((3^n-2^(n+1)+1)/2)%p 
    long x = (power(3, n) % p + 1) % p; 
  
    x = (x - power(2, n + 1) + p) % p; 
  
    // From Fermats's little theorem 
    // a^-1 ? a^(m-2) (mod m) 
  
    x = (x * power(2, p - 2)) % p; 
    System.out.println(x); 
} 
} 
  
// This code is contributed by Rajput-Ji 

Python3

# Python3 implementation of the approach 
p = 1000000007
  
# Modulo exponentiation function 
def power(x, y): 
      
    # Function to calculate (x^y)%p in O(log(y)) 
    res = 1
    x = x % p 
  
    while (y > 0): 
        if (y & 1): 
            res = (res * x) % p; 
        y = y >> 1
        x = (x * x) % p 
  
    return res % p 
  
# Driver Code 
n = 3
  
# Evaluating ((3^n-2^(n+1)+1)/2)%p 
x = (power(3, n) % p + 1) % p 
  
x = (x - power(2, n + 1) + p) % p 
  
# From Fermats’s little theorem 
# a^-1 ? a^(m-2) (mod m) 
x = (x * power(2, p - 2)) % p 
  
print(x) 
  
# This code is contributed by Mohit Kumar 

C#

// C# implementation of the approach 
using System; 
  
class GFG 
{ 
static int p = 1000000007; 
  
// Modulo exponentiation function 
static long power(long x, long y) 
{ 
    // Function to calculate (x^y)%p in O(log(y)) 
    long res = 1; 
    x = x % p; 
  
    while (y > 0) 
    { 
        if (y % 2 == 1) 
            res = (res * x) % p; 
        y = y >> 1; 
        x = (x * x) % p; 
    } 
    return res % p; 
} 
  
// Driver Code 
static public void Main () 
{ 
    long n = 3; 
      
    // Evaluating ((3^n-2^(n+1)+1)/2)%p 
    long x = (power(3, n) % p + 1) % p; 
      
    x = (x - power(2, n + 1) + p) % p; 
      
    // From Fermats's little theorem 
    // a^-1 ? a^(m-2) (mod m) 
      
    x = (x * power(2, p - 2)) % p; 
    Console.Write(x); 
} 
} 
  
// This code is contributed by ajit. 

Output:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: