Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Count of Subsequences of given string X in between strings Y and Z
A subsequence is a string that can be achieved from another string by removing some (possibly none or all) from a given string that may not be continuous. We are given a string and have to find the number of subsequences that are greater than equal to the given string Y and less than equal to another given string Z. We will use dynamic programming to solve the problem as brute force will take exponential time.
Brute Force Approach
The brute forces approach is to find all the subsequences of the given string X and then check if they are lying in the given range. If the current subsequence is lying in the given range then we will increase the count.
Example
#include <bits/stdc++.h>
using namespace std;
// global varaibles
string x, y, z;
int len_x, len_y, len_z;
// recursive function
int rec(string& cur, int i){
// defining the base cases
if(i == len_x){
if(cur <=z && cur >= y){
return 1;
} else {
return 0;
}
}
int ans = rec(cur, i + 1);
cur.push_back(x[i]);
ans += rec(cur, i + 1);
cur.pop_back();
return ans;
}
// function to get the number of subsequences less than Z and greater than Y
int getCount(string X, string Y, string Z){
string cur = ""; // initializing empty string
// getting the length of the given strings
len_x = X.size();
len_y = Y.size();
len_z = Z.size();
// calling to the recursive function to get the result
return rec(cur, 0);
}
int main(){
// given strings
x = "abc";
y = "a";
z = "bc";
// edge case, if the given string y is greater than z
// return zero
if(y > z){
cout<<"The number of subsequences of given string X in between strings Y and Z are: "<<0<<endl;
} else {
// calling the function
cout<<"The number of subsequences of given string X in between strings Y and Z are: "<<getCount(x,y,z) <<endl;
}
return 0;
}
Output
The number of subsequences of given string X in between strings Y and Z are: 6
Time and Space Complexity
The time complexity of the above code is O((2^N) * N), where N is the size of the given string.
The space complexity of the above code is O(N), as we are using a string to store the current string.
Dynamic Programming Approach
We will make choice at each of the index, in first choice we will skip the current index value and move to the next value and for the second choice we will check if by adding the current character to the string is it in the range of not.
If by adding the current element in the string we will get result in the range then we will add to the answer. Also, if we already have visited this state then we will return already stored answer.
Example
#include <bits/stdc++.h>
using namespace std;
// array to store the state results
int memo[105][105][2][2];
// global variables
string x, y, z;
int len_x, len_y, len_z;
// recursive function
int rec(int i, int j, bool var1, bool var2){
// defining the base cases
if(i == len_x){
// if subsequence is empty then return 0
if (j == 0){
return 0;
}
if(var1 == false || j >= len_y){
return 1;
} else {
return 0;
}
}
// if the memo array contains this item then return it
if(memo[i][j][var1][var2] != -1){
return memo[i][j][var1][var2];
}
// skip the current index
int res = rec(i + 1, j, var1, var2);
// variable to mark the position of current index
int canAdded = 0;
if(var1 == false) {
canAdded = 1;
} else if ((j >= len_y) || (x[i] >= y[j])) {
canAdded = 1;
var1 &= ((j < len_y) && x[i] == y[j]);
}
if (var2 == false){
canAdded ++;
} else if((j < len_z) && x[i] <= z[j]){
canAdded++;
var2 &= (x[i] == z[j]);
}
if (canAdded == 2){
// increase both i and j by 1
res += rec(i + 1, j + 1, var1, var2);
}
// store the answer in memo array
memo[i][j][var1][var2] = res;
return res;
}
// function to get the number of subsequences less than Z and greater than Y
int getCount(string X, string Y, string Z){
// initialize the memo function
memset(memo, -1, sizeof(memo));
// getting the lenght of the given strings
len_x = X.size();
len_y = Y.size();
len_z = Z.size();
// calling to the recursive function to get the result
return rec(0, 0, 1, 1);
}
int main(){
// given strings
x = "abc";
y = "a";
z = "bc";
// edge case, if the given string y is greater than z
// return zero
if(y > z){
cout<<"The number of subsequences of given string X in between strings Y and Z are: "<<0<<endl;
} else {
// calling the function
cout<<"The number of subsequences of given string X in between strings Y and Z are: "<<getCount(x,y,z) <<endl;
}
return 0;
}
Output
The number of subsequences of given string X in between strings Y and Z are: 6
Time and Space Complexity
The time complexity of the above code is O(N*N), where N is the size of the given string.
The space complexity of the above code is O(N*N), as we are using an array to store the results or the states.
Conclusion
In this tutorial, we have implemented a program to find the number of subsequences of string X that are lying in between the given strings Y and Z. We have seen the simple brute force method which is in-efficient and then we have implemented the efficient dynamic programming code with the time complexity of O(N*N) and same space complexity.
59 Views
