new question added

Author: arorarahul

README.md

@@ -398,6 +398,7 @@ it gets converted to i-1,j-1 or we take min or max of i,j-1 and i-1,j
 - [Given n-stairs, how many number of ways a person can climb to top from bottom using 1 step or 2 steps](/dynamic-programming/question22.c)
 - [Longest non-overlapping repeating sub string](/dynamic-programming/question23.c)
 - [Given two strings X and Y, find the minimum cost to make two strings equal using only delete operations. Cost to delete character in X is S and in Y is P](/dynamic-programming/question24.c)
+- [Count the number of times string occured as the subsequence of the other string](/dynamic-programming/question25.c)
 
 ## Some important concepts to solve algos better
 
@@ -408,7 +409,7 @@ it gets converted to i-1,j-1 or we take min or max of i,j-1 and i-1,j
 - 'XOR' of zero with a number is the number itself
 - '1s compliment is number obtained by reversing all the bits in the binary representation of a number. o to 1 and 1 to 0'
 - Linear hashing is (h(k) + i)modm (where m is the size of the hash table, h(k) is the hash function that takes the key k and returns a value i is the parameter that is incremented to get different values)
-- Subarrays of an array are always contiguous whereas subsequence may not be contiguous
+- Subarrays of an array are always contiguous whereas subsequence may not be contiguous but needs to be in the increasing order. Same applies to a string as well.
 - There are only two ways to make any data structure one is to use an array (where size is fixed and memory is contiguous) OR you can use the heap memory (structures and linked list). So Array and linked list or combo of these two are used to implement any data structure. In most cases linked list takes more time to do operations if data structure is implemented using it. But advantage is dynamic memory allocation
 - For INFIX to POSTFIX conversion, data structure used is stack. In stack all the operators are stored. For evaluation of POSTFIX stack is used to store operands
 - Evaluating and expression = convert from INFIX to postfix --> Evaluate POSTFIX. Time complexity: O(n)

dynamic-programming/question25.c

@@ -0,0 +1,94 @@
+/*
+Count the number of times string occured as the subsequence of the other string
+
+METHOD1:
+Naive approach, where we find all the subsequences and see whenever that subsequence is equal to the string
+given. This will take exponential time
+
+METHOD2:
+We can find the LCS which will be ideally equal to the length of the string given in the second case.
+If the solution is also the string that is okay otherwise the string does not repeat even once.
+Now if the solution is the string we can go back and construct the total number of solutions which are
+of that length (because obviously if they are of length equal to the string, it will be the string itself)
+Hence we can maintain a counter for that and return its value
+
+Time complexity: O(mn) //LCS
+Space complexity: O(mn)
+
+Rest can be done in lesser time as compared to this, hence the answer
+
+
+METHOD3:
+Dynamic programming but not using LCS:
+Here we first try to write the recusive equations
+
+c[i,j] = {
+	c[i-1][j] + c[i-1][j-1] //if equal
+	//that means we search the matched value in the remaining string as well as ignoring the matched value
+	searching the rest in the remaining string
+
+	c[i-1][j] //if the value does not match		
+}
+
+We convert it into a program and we will get the answer.
+c[i,j] represents count of total number of times string till jth position occur in the string till ith position
+
+Time complexity: O(mn)
+Space complexity: O(mn)
+
+*/
+//METHOD3
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int findCount(char *str1, char *str2){
+
+	int len1 = strlen(str1);
+	int len2 = strlen(str2);
+
+	int sol[len1+1][len2+1];
+
+	int i,j;
+	for(i=0;i<=len1;i++){
+		sol[i][0] = 1;
+	}
+
+	for(j=1;j<=len2;j++){
+		sol[0][j] = 0;
+	}
+
+	for(i=1;i<=len1;i++){
+		for(j=1;j<=len2;j++){
+			if(str1[i-1] == str2[j-1]){
+				sol[i][j] = sol[i-1][j-1] + sol[i-1][j];
+			}else{
+				sol[i][j] = sol[i-1][j];
+			}
+		}
+	}
+
+	printf("the sol array is\n");
+
+	for(i=0;i<=len1;i++){
+		for(j=0;j<=len2;j++){
+			printf("%d ", sol[i][j]);
+		}
+		printf("\n");
+	}
+
+	return sol[len1][len2];
+
+}
+
+int main(){
+	char str1[] = "GeeksforGeeks";
+	char str2[] = "Gks";
+
+	int count = findCount(str1, str2);
+
+	printf("count is %d\n", count);
+
+	return 0;
+}
+

nextquestions.md

@@ -90,5 +90,6 @@ TODO:
 - finding all palindromes in a given string
 - generalize the steps in question22 to m steps at a time
 - DP question23 to be done
+- DP solution to be constructed for LCS problem