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: 1Input: 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 Fermats’s little theorem
a-1 = a(m – 2) (mod m) for modular divisionBelow 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:6
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.