Given an array nums[] of N positive integers, the task is to find the number of subsequences that can be created from the array where each subsequence contains all integers from 1 to its size in any order. If two subsequences have different chosen indices, then they are considered different.
Examples:
Input: N = 5, nums = {1, 2, 3, 2, 4}
Output: 7
Explanation: There are 7 subsequences present in the given array which has the size of M and contains integers from 1 to M. The subsequences are: [1], [1, 2], [1, 2], [1, 2, 3], [1, 3, 2], [1, 2, 3, 4], and [1, 3, 2, 4]Input: N = 7, nums = {1, 3, 5, 8, 9, 8, 2}
Output: 3
Explanation: The three subsequences present in the given array are: [1], [1, 2], and [1, 3, 2].
Approach: This can be solved with the following idea:
First of all, we will make a frequency map using the hash map. Suppose we have given the array, nums = [1, 2, 3, 2, 4] then the frequency map will be like:
[[1 -> 1], [2 -> 2], [3 -> 1], [4 -> 1]].
- Now we will start iterating from i = 1, we will continue the iteration till the frequency map contains a key equal to i.
- As for i = 2, the above case has a frequency value of 2, now we will check how many arrays we can make using i = 1, and we know it is 1, therefore the number of arrays we can make of size 2 such that it contains elements 1 and 2 will be: (number of arrays we can make of size 1) * (frequency value of 2). For the above case, it will be: 1 * 2 = 2, so till i = 2 we can make two arrays of size 2 and 1 array of size 1, the total value(answer variable) will be: 2 + 1 = 3.
- For i = 3, the above case has a frequency value of 1, and the number of arrays we can create of size 2 is 2, so the number of arrays of size 3 we can create will be: (2 * 1) = 2, answer variable will get updated as: 3 + 2 = 5.
- For i = 4, the above case has a frequency value of 1, and the number of arrays we can create of size 2 is 2, so the number of arrays of size 4 we can create will be: (2 * 1) = 2, answer variable will get updated as: 5 + 2 = 7.
To implement the above intuition follow the below-given steps:
- Firstly, make a hash map freq, which stores the frequency value of every element.
- Initialize our answer variable with a frequency value of 1 and also initialize a last variable which contains the value of a number of arrays we can make of size i – 1.
- Start iterating with i = 2, until it doesn’t contain in the frequency map.
- For every i, find a number of arrays you can make and update it in the answer variable also don’t forget to take modulo with 1000000007.
- Return the answer.
Below is the implementation of the above approach:
// C++ algorithm for the above approach #include <iostream> #include <unordered_map> using namespace std;
// Function which will return number // of arrays we can make int makeArrays( int nums[], int N)
{ // Making frequency map of the given array nums
unordered_map< int , int > freq;
for ( int i = 0; i < N; i++) {
freq[nums[i]] = freq[nums[i]] + 1;
}
long long mod = 1000000007;
// Initializing ans variable
long long ans = (freq.count(1)) ? freq[1] : 0;
// Initializing last variable
long long last = ans;
int i = 2;
// Iterating after i = 1
while (freq.count(i)) {
last = (last * freq[i]) % mod;
ans = (ans + last) % mod;
i++;
}
// Returning answer
return static_cast < int >(ans);
} // Driver Code int main()
{ int nums[] = { 1, 3, 5, 8, 9, 8, 2 };
int N = sizeof (nums) / sizeof (nums[0]);
cout << makeArrays(nums, N) << endl;
return 0;
} |
// Java algorithm for above approach import java.util.*;
class GFG {
// Driver Code
public static void main(String[] args)
{
int [] nums = { 1 , 3 , 5 , 8 , 9 , 8 , 2 };
int N = nums.length;
System.out.println(makeArrays(nums, N));
}
// Function which will return number
// of arrays we can make
public static int makeArrays( int [] nums, int N)
{
// Making frequency map of
// the given array nums
Map<Integer, Integer> freq = new HashMap<>();
for ( int i = 0 ; i < N; i++) {
freq.put(nums[i],
freq.getOrDefault(nums[i], 0 ) + 1 );
}
long mod = 1000000007 ;
// Initializing ans variable
long ans = (freq.containsKey( 1 )) ? freq.get( 1 ) : 0 ;
// Initializing last variable
long last = ans;
int i = 2 ;
// Iterating after i = 1
while (freq.containsKey(i)) {
last = (last * freq.get(i)) % mod;
ans = (ans + last) % mod;
i++;
}
// Returning answer
return ( int )(ans);
}
} |
def make_arrays(nums):
freq = {}
# Count the frequency of each number
for num in nums:
freq[num] = freq.get(num, 0 ) + 1
mod = 1000000007
ans = freq.get( 1 , 0 )
last = ans
i = 2
# Iterate over the numbers and calculate the answer
while i in freq:
last = (last * freq[i]) % mod
ans = (ans + last) % mod
i + = 1
# Return the answer
return ans
# Example usage nums = [ 1 , 3 , 5 , 8 , 9 , 8 , 2 ]
print (make_arrays(nums)) # Output: 7
|
// C# program for above approach using System;
using System.Collections.Generic;
class GFG {
// Function which will return number
// of arrays we can make
static int makeArrays( int [] nums, int N)
{
// Making frequency map of
// the given array nums
Dictionary< int , int > freq
= new Dictionary< int , int >();
int i;
for (i = 0; i < N; i++) {
if (freq.ContainsKey(nums[i]))
freq[nums[i]]++;
else
freq.Add(nums[i], 1);
}
long mod = 1000000007;
// Initializing ans variable
long ans = (freq.ContainsKey(1)) ? freq[1] : 0;
// Initializing last variable
long last = ans;
i = 2;
// Iterating after i = 1
while (freq.ContainsKey(i)) {
last = (last * freq[i]) % mod;
ans = (ans + last) % mod;
i++;
}
// Returning answer
return ( int )(ans);
}
// Driver Code
public static void Main()
{
int [] nums = { 1, 3, 5, 8, 9, 8, 2 };
int N = nums.Length;
Console.Write(makeArrays(nums, N));
}
} // This code is contributed by Tapesh(tapeshdua420) |
// Function which will return number of arrays we can make function makeArrays(nums) {
// Making frequency map of the given array nums
const freq = new Map();
for (let i = 0; i < nums.length; i++) {
freq.set(nums[i], (freq.get(nums[i]) || 0) + 1);
}
const mod = 1000000007;
// Initializing ans variable
let ans = freq.has(1) ? freq.get(1) : 0;
// Initializing last variable
let last = ans;
let i = 2;
// Iterating after i = 1
while (freq.has(i)) {
last = (last * freq.get(i)) % mod;
ans = (ans + last) % mod;
i++;
}
// Returning answer
return ans;
} // Driver Code const nums = [1, 3, 5, 8, 9, 8, 2]; console.log(makeArrays(nums)); |
3
Time Complexity: O(N)
Auxiliary Space: O(N)