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

Approach:

  1. Lets assume there are only 6 elements in the set {1, 2, 3, 4, 5, 6}.
  2. When you count the number of subsets with 1 as one of the element of first subset, it comes out to be 211.
  3. 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.
  4. 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.
  5. 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)

  6. Expanding it until n->2 (means numbers of elements n-2+1=n-1)
    2(n-2) * 3(0) + 2(n – 3) * 31 + 2(n – 4) * 32 + 2(n – 5) * 33 + … + 2(0) * 3(n – 2)
    From Geometric progression, a + a * r0 + a * r1 + … + a * r(n – 1) = a * (rn – 1) / (r – 1)
  7. 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)
  8. It also forms a Geometric progression, so we calculate it by formula of sum of GP
    T(n) = (3n – 2n + 1 + 1)/2
  9. As we require T(n) % p where p = 109 + 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++

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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";
      }

      chevron_right

      
      

      Java

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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

      chevron_right

      
      

      Python3

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      # 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

      chevron_right

      
      

      C#

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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.

      chevron_right

      
      

      Output:

      6
      


      My Personal Notes arrow_drop_up

      Competitive Programmer, Full Stack Developer, Technical Content Writer, Machine Learner

      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.