Given an integer N, the task is to count the number of subsets formed from an array of integers from 1 to N which doesn’t contain adjacent elements. A subset can’t be chosen if it satisfies the non-adjacent element condition, but it is possible to add more elements.
Examples:
Input: N = 4 Output: 3 Explanation: Array is {1, 2, 3, 4} So to satisfy the condition, the subsets formed are : {1, 3}, {2, 4}, {1, 4} Input: N = 5 Output: 4
Approach:
This problem can be solved by using Dynamic Programming. For the last element, we have two choices, either we include it, or we exclude it. Let DP[i] be the number of our desirable subsets ending at index i.
So next Subproblem becomes DP[i-3]
So the DP relation becomes :
DP[i] = DP[i-2] + DP[i-3]
But, we need to observe the base cases:
- When N=0, we cannot form any subset with 0 numbers.
- When N=1, we can form 1 subset, {1}
- When N=2, we can form 2 subsets, {1}, {2}
- When N=3, we can form 2 subsets, {1, 3}, {2}
Below is the implementation of above approach:
// C++ Code to count subsets not containing // adjacent elements from 1 to N #include <bits/stdc++.h> using namespace std;
// Function to count subsets int countSubsets( int N)
{ if (N <= 2)
return N;
if (N == 3)
return 2;
int DP[N + 1] = {0};
DP[0] = 0, DP[1] = 1, DP[2] = 2, DP[3] = 2;
for ( int i = 4; i <= N; i++) {
DP[i] = DP[i - 2] + DP[i - 3];
}
return DP[N];
} // Driver Code int main()
{ int N = 20;
cout << countSubsets(N);
return 0;
} |
// Java code to count subsets not containing // adjacent elements from 1 to N class GFG{
// Function to count subsets static int countSubsets( int N)
{ if (N <= 2 )
return N;
if (N == 3 )
return 2 ;
int []DP = new int [N + 1 ];
DP[ 0 ] = 0 ;
DP[ 1 ] = 1 ;
DP[ 2 ] = 2 ;
DP[ 3 ] = 2 ;
for ( int i = 4 ; i <= N; i++)
{
DP[i] = DP[i - 2 ] + DP[i - 3 ];
}
return DP[N];
} // Driver code public static void main(String[] args)
{ int N = 20 ;
System.out.print(countSubsets(N));
} } // This code is contributed by sapnasingh4991 |
# Python3 Code to count subsets # not containing adjacent elements # from 1 to N # Function to count subsets def countSubsets(N):
if (N < = 2 ):
return N
if (N = = 3 ):
return 2
DP = [ 0 ] * (N + 1 )
DP[ 0 ] = 0
DP[ 1 ] = 1
DP[ 2 ] = 2
DP[ 3 ] = 2
for i in range ( 4 , N + 1 ):
DP[i] = DP[i - 2 ] + DP[i - 3 ]
return DP[N]
# Driver Code if __name__ = = '__main__' :
N = 20
print (countSubsets(N))
# This code is contributed by Mohit Kumar |
// C# code to count subsets not containing // adjacent elements from 1 to N using System;
class GFG{
// Function to count subsets static int countSubsets( int N)
{ if (N <= 2)
return N;
if (N == 3)
return 2;
int []DP = new int [N + 1];
DP[0] = 0;
DP[1] = 1;
DP[2] = 2;
DP[3] = 2;
for ( int i = 4; i <= N; i++)
{
DP[i] = DP[i - 2] + DP[i - 3];
}
return DP[N];
} // Driver code public static void Main(String[] args)
{ int N = 20;
Console.Write(countSubsets(N));
} } // This code is contributed by sapnasingh4991 |
<script> // javascript code to count subsets not containing // adjacent elements from 1 to N // Function to count subsets function countSubsets(N) {
if (N <= 2)
return N;
if (N == 3)
return 2;
var DP = Array(N + 1).fill(0);
DP[0] = 0;
DP[1] = 1;
DP[2] = 2;
DP[3] = 2;
for (i = 4; i <= N; i++) {
DP[i] = DP[i - 2] + DP[i - 3];
}
return DP[N];
}
// Driver code
var N = 20;
document.write(countSubsets(N));
// This code contributed by gauravrajput1 </script> |
265
Time Complexity: O(N)
Space Complexity: O(N)
Efficient approach: Space-optimized approach
In this approach, we optimize the space by using variables.
Implementation steps :
- Initialize variables to store previous computations : prev1, prev2 , prev3, prev4
- The current computation is depend upon the prev3 and prev2.
- After every iteration update these variables to iterate further.
- At last return answer stored in curr.
Implementation:
// C++ Code to count subsets not containing // adjacent elements from 1 to N #include <bits/stdc++.h> using namespace std;
// Function to count subsets int countSubsets( int N)
{ // Base Case
if (N <= 2)
return N;
if (N == 3)
return 2;
int prev1 = 0, prev2 = 1, prev3 = 2, prev4 = 2 , curr;
for ( int i = 4; i <= N; i++) {
curr = prev3 + prev2;
// assigning value to iterate further
prev1 = prev2;
prev2= prev3;
prev3 = prev4;
prev4 = curr;
}
// return answer
return curr;
} // Driver Code int main()
{ int N = 20;
// function call
cout << countSubsets(N);
return 0;
} |
// Java program for above approach import java.util.*;
public class Main {
// Function to count subsets
public static int countSubsets( int N)
{
// Base Case
if (N <= 2 ) {
return N;
}
if (N == 3 ) {
return 2 ;
}
int prev1 = 0 , prev2 = 1 , prev3 = 2 ;
int prev4 = 2 , curr = 0 ;
// loop to get the current value
// from previous computations
for ( int i = 4 ; i <= N; i++) {
curr = prev3 + prev2;
// assigning value to iterate further
prev1 = prev2;
prev2 = prev3;
prev3 = prev4;
prev4 = curr;
}
// return answer
return curr;
}
// Driver Code
public static void main(String[] args)
{
int N = 20 ;
System.out.println(countSubsets(N));
}
} |
# Python3 Code to count subsets not containing # adjacent elements from 1 to N # Function to count subsets def countSubsets(N):
# Base Case
if (N < = 2 ):
return N
if (N = = 3 ):
return 2
prev1 = 0
prev2 = 1
prev3 = 2
prev4 = 2
curr = 0
for i in range ( 4 , N + 1 ):
curr = prev3 + prev2
# assigning value to iterate further
prev1 = prev2
prev2 = prev3
prev3 = prev4
prev4 = curr
# return answer
return curr
# Driver Code N = 20
# function call print (countSubsets(N))
|
// C# program for above approach using System;
class MainClass {
// Function to count subsets
public static int CountSubsets( int N)
{
// Base Case
if (N <= 2) {
return N;
}
if (N == 3) {
return 2;
}
int prev1 = 0, prev2 = 1, prev3 = 2, prev4 = 2,
curr = 0;
// loop to get the current value from previous
// computations
for ( int i = 4; i <= N; i++) {
curr = prev3 + prev2;
// assigning value to iterate further
prev1 = prev2;
prev2 = prev3;
prev3 = prev4;
prev4 = curr;
}
// return answer
return curr;
}
// Driver Code
public static void Main( string [] args)
{
int N = 20;
// function call
Console.WriteLine(CountSubsets(N));
}
} |
// Function to count subsets function countSubsets(N) {
// Base Case
if (N <= 2) {
return N;
}
if (N == 3) {
return 2;
}
let prev1 = 0, prev2 = 1, prev3 = 2, prev4 = 2 , curr;
for (let i = 4; i <= N; i++) {
curr = prev3 + prev2;
// assigning value to iterate further
prev1 = prev2;
prev2= prev3;
prev3 = prev4;
prev4 = curr;
}
// return answer
return curr;
} // Driver Code const N = 20; // function call console.log(countSubsets(N)); |
265
Time Complexity: O(N)
Auxiliary Space: O(1)