dynamic-programming | fibonacci using matrix

Author: arorarahul

README.md

@@ -212,6 +212,22 @@ Implementation using trees is better as we can apply union by rank and path comp
 In case of linked list find takes O(n) time and union also takes O(n) time and create takes O(1) time
 
 
+## Back Tracking
+
+- Permutations means ordered combinations. Eg. My juice is made by a combination of 10 fruits (order does not matter), but in case of permutations the order does matter. Basically changing the order can change the outcome means permutations. Changing the order has no effect on outcome is combination
+- Backtracking uses recursion where each call in the stack has its stored values and backtracking makes
+use of those values to do decision making at a particular level in the recursion tree
+
+## Pattern Matching
+
+- For KMP to find all occurences of a pattern in a string, whenever the match is found, we assign the 
+pointer of pattern variable value that is there in the prefix suffix array at an index less then the
+current value of the pointer and we start comparing again.
+- Boyer-Moore algorithm is much more efficient than KMP at places where pattern to be searched has characters
+as different as possible. If the characters are same, then in worst case it will give a time complexity of
+O(mn) where it will end up comparing most of the characters, therefore, in case characters are mostly same
+use KMP
+
 # Topic0: Programming Questions
 
 ## Note:
@@ -439,6 +455,7 @@ In case of linked list find takes O(n) time and union also takes O(n) time and c
 - [Find the sum of digits for all numbers from 1 to N for a given N](/dynamic-programming/question30.c)
 - [Given a string of digits, find the length of the longest substring of a string, such that the length of the substring is '2k' digits and sum of left k digits is equal to the sum of right k digits](/dynamic-programming/question31.c)
 - [Given a rod of length 'n' inches and an array of prices that contains prices of all pieces of size smaller than n, find the max value obtainable by cutting the rod and selling the pieces](/dynamic-programming/question32.c)
+- [Fibonacci series](/dynamic-programming/question33.c)
 
 ### Graphs
 
@@ -453,7 +470,17 @@ In case of linked list find takes O(n) time and union also takes O(n) time and c
 
 
 ### Pattern Matching
+
 - [Given a text and a pattern, find all occurences of a pattern in a given text.](/pattern-matching/question1.c)
+- [Implement KMP algorithm to find all occurences of a pattern in a given text](/pattern-matching/question2.c)
+- [Boyer-Moore algorithm for string finding patterns](/pattern-matching/question3.c)
+- [Rabin-Karp for string finding patterns](/pattern-matching/question4.c)
+
+### Back Tracking
+
+- [Generate all permutations of a given string](/back-tracking/question1.c)
+- [Program to generate all strings of n bits](/back-tracking/question2.c)
+- [N-queens problem](/back-tracking/question3.c)
 
 ### MISC
 

back-tracking/question1.c

@@ -0,0 +1,69 @@
+/*
+Generate all permutations of a given string
+
+Backtracking is a concept wherein at each point we backtrack to see what was done and was is left
+
+METHOD:
+Idea is to keep swapping at each level to achieve this
+
+*/
+// C program to print all permutations with duplicates allowed
+#include <stdio.h>
+#include <string.h>
+#include <string.h>
+
+int hash[256];
+
+void initHash(){
+	int i;
+	for(i=0;i<256;i++){
+		hash[i] = 0;
+	}
+}
+
+void outputResult(char *result){
+	int i, length = strlen(result);
+
+	for(i=0;i<length;i++){
+		printf("%c ", result[i]);
+	}
+	printf("\n");
+}
+
+
+void permute(char *str, int size, char *result, int level){
+
+	if(level == size){
+		outputResult(result);
+		return;
+	}
+
+	int i;
+	for(i=0; i<size; i++){
+		if(hash[str[i]] == 0){
+			continue;
+		}
+		result[level] = str[i];
+		hash[str[i]]--;
+		permute(str, size, result, level + 1);
+		hash[str[i]]++;
+	}
+}
+
+int main(){
+	char str[] = "ABC";
+	int length = strlen(str);
+
+	char result[length];
+
+	int i;
+
+	initHash();
+	for(i=0;i<length;i++){
+		hash[str[i]]++;
+	}
+
+	permute(str,length,result,0);
+
+	return 0;
+}

back-tracking/question2.c

@@ -0,0 +1,40 @@
+/*
+Program to generate all strings of n bits
+
+Here we use recursion
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void display(int *arr, int n){
+	int i;
+	for(i=0;i<n;i++){
+		printf("%d ", arr[i]);
+	}
+	printf("\n");
+}
+
+void generate(int start, int end, int *arr, int size){
+	if(start == end){
+		display(arr,size);
+		return;
+	}
+	arr[start] = 0;
+	generate(start + 1,end, arr, size);
+	arr[start] = 1;
+	generate(start + 1,end, arr, size);
+}
+
+int main(){
+	
+	printf("enter the value of n:\n");
+	int n;
+	scanf("%d",&n);
+
+	int arr[n];
+
+	generate(0,n,arr,n);
+
+	return 0;
+}

back-tracking/question3.c

@@ -0,0 +1,74 @@
+/*
+N-queens problem
+There is a NXN chessboard. You have to write a program to place 4 queens in such a way that
+they do not attack each other.
+
+Naive Approach:
+We can place the first queen in n^2 ways,
+second in n^2-1 ,third in -2 and so on.
+
+Lets say n=4
+
+Then in worst case we will have n^2cn total combinations of placing the queens and it will take us n^2 time
+to validate each combination to see if thats the right position for the queens to not kill each other.
+
+Time complexity: O(n^2cn)n^2
+
+METHOD2:
+Here we can restrict the queen per row. Therefore every queen will have 4 ways to select a cell
+4 X 4 X 4 X 4 for all the 4 queens
+Hence total ways n^n
+
+Time complexity O(n^n)n^2 //to validate what all ways are correct
+
+METHOD3: We can restrict the queens by row and column both. First queen will then have 4 ways, second will
+have 3 ways as 1 column is also gone, third will have 2 and so on.
+
+4 X 3 X 2 X 1.
+
+Time complexity: O(n!)n^2
+
+METHOD4:
+Here we can use backtracking at each step to see if we are heading in the right direction.
+
+Lets say first queen is placed at first cell (and we are going in ascending order), second will be placed in
+next row in 2,3 or 4 column. In second column it cannot be placed, so we place it in third.
+
+Now third queen cannot be placed in first or third and cannot be placed in 2nd or 4th as it will be killed by
+second queen, hence we backtrack and change position of q2, and move it to 4th place. This way q3 can now
+be placed in second column.
+
+Now llarly for 4th queen it cannot be placed anywhere so we backtrack to change position of q3, which also cannot
+be placed anywhere else, we backtrack to change q2, for which all positions are over, so we backtrack to change
+position for q1 until we find the right match for all. 
+
+Time complexity in this case cannot be measured as we dont know how many times will the backtracking take place
+but it is definately less then O(n!)n^2 
+
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+void init(int n, int arr[n][n]){
+	int i,j;
+	for(i=0;i<n;i++){
+		for(j=0;j<n;j++){
+			arr[i][j] = 0; //0 means cell is empty
+		}
+	}
+}
+
+int main(){
+	int n;
+	printf("enter the value of n\n");
+	scanf("%d",&n);
+
+	int arr[n][n];
+
+	init(n,arr);
+
+	findNQueen()
+	
+	return 0;
+}
+

back-tracking/question4.c

@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void display(int f[2][2]){
+	int i,j;
+	printf("-------------------\n");
+	for(i=0;i<2;i++){
+		for(j=0;j<2;j++){
+			printf("%d ", f[i][j]);
+		}
+		printf("\n");
+	}
+	printf("----------------\n");
+}
+
+void mul(int a[2][2], int b[2][2]){
+	int p = a[0][0]*b[0][0] + a[0][1]*b[1][0];
+	int q = a[0][0]*b[0][1] + a[0][1]*b[1][1];
+	int r = a[1][0]*b[0][0] + a[1][1]*b[1][0];
+	int s = a[1][0]*b[0][1] + a[1][1]*b[1][1];
+
+	a[0][0] = p;
+	a[0][1] = q;
+	a[1][0] = r;
+	a[1][1] = s;
+}
+
+
+void ipow(int f[2][2], int power){
+	
+	if(power <= 1){
+		return;
+	}
+
+	int base[2][2] = {
+		{1,1},
+		{1,0}
+	};
+
+	mul(f,f);
+
+	ipow(f,power/2);			
+
+	if(power%2 != 0){
+		mul(f,base);
+	}
+
+}
+
+void ipowIterative(int f[2][2],int power){
+
+	int base[2][2] = {
+		{1,1},
+		{1,0}
+	};
+	
+	while(power > 1){
+		mul(f,f);
+		if(power%2 !=0){
+			mul(f,base);
+		}
+		power = power/2;
+	}
+	
+}
+
+int fib(int n){
+	int f[2][2] = {
+		{1,1},
+		{1,0}
+	};
+	printf("calling pow with power %d\n", n-1);
+	ipowIterative(f,n-1);
+
+	return f[0][0];
+}
+
+int main(){
+
+	int n = 11;
+
+	printf("answer is %d\n", fib(n));
+
+	return 0;
+}

dynamic-programming/question33.c

@@ -0,0 +1,46 @@
+/*
+Additive sequence
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int isAdditive(char *str){
+	int length = strlen(str);
+
+	int isAdditive = 1;
+
+	int i;
+
+
+
+	printf("%d\n", str[length-1]-'0');
+	// for(i=2;i<length;i++){
+	// 	printf("comparing %d with %d and %d ", str[i]-'0',str[i-1]-'0',str[i-2]-'0');
+	// 	if((str[i]-'0') != ((str[i-1]-'0') + (str[i-2] - '0'))){
+	// 		return 0;
+	// 	}
+	// }
+
+	return isAdditive;
+}
+
+int main(){
+
+	int cases;
+	scanf("%d", &cases);
+
+	char str[200];
+
+	int i;
+	for(i=0;i<cases;i++){
+		scanf("%s",str);
+		if(isAdditive(str)){
+			printf("%d\n", 1);
+		}else{
+			printf("%d\n", 0);
+		}
+	}
+
+	return 0;
+}

misc/question3.c

@@ -108,4 +108,6 @@ TODO:
 - breadth and depth first traversal in a tree
 - Graphs question6 union and find method to be done
 - Graphs question8 to be done along with backedges
+- Try Boyer-Moore and Rabin-karp in pattern matchin question3 and 4
+- Back tracking - program to print all permutations question1 (some problem)