Count of all possible pairs of disjoint subsets of integers from 1 to N
Last Updated :
16 Nov, 2022
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
Explanation: 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:
- 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(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)
- 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) = (3n – 2n + 1 + 1)/2
- As we require T(n) % p where p = 109 + 7 We have to use Fermat’s little theorem a-1 = a(m – 2) (mod m) for modular division
C++
#include <bits/stdc++.h>
using namespace std;
#define p 1000000007
long long power( long long x, long long 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;
}
int main()
{
long long n = 3;
long long x = (power(3, n) % p + 1) % p;
x = (x - power(2, n + 1) + p) % p;
x = (x * power(2, p - 2)) % p;
cout << x << "\n" ;
}
|
Java
class GFG
{
static int p = 1000000007 ;
static long power( long x, long 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;
}
public static void main(String[] args)
{
long n = 3 ;
long x = (power( 3 , n) % p + 1 ) % p;
x = (x - power( 2 , n + 1 ) + p) % p;
x = (x * power( 2 , p - 2 )) % p;
System.out.println(x);
}
}
|
Python3
p = 1000000007
def power(x, 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
n = 3
x = (power( 3 , n) % p + 1 ) % p
x = (x - power( 2 , n + 1 ) + p) % p
x = (x * power( 2 , p - 2 )) % p
print (x)
|
C#
using System;
class GFG
{
static int p = 1000000007;
static long power( long x, long 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;
}
static public void Main ()
{
long n = 3;
long x = (power(3, n) % p + 1) % p;
x = (x - power(2, n + 1) + p) % p;
x = (x * power(2, p - 2)) % p;
Console.Write(x);
}
}
|
Javascript
let p = 1000000007n
function power(x, y)
{
let res = 1n;
x = x % p;
while (y > 0n) {
if (y & 1n)
res = (res * x) % p;
y = y >> 1n;
x = (x * x) % p;
}
return res % p;
}
let n = 3n;
let x = (power(3n, n) % p + 1n) % p;
x = (x - power(2n, n + 1n) + p) % p;
x = (x * power(2n, p - 2n)) % p;
console.log(x)
|
Time Complexity: O(log(n)+log(p))
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...