From 4f78c66abb7618e8b9c0061ebd204c69bf44a889 Mon Sep 17 00:00:00 2001
From: Girish Garg <girishgargcool@gmail.com>
Date: Wed, 30 Sep 2020 23:08:12 +0530
Subject: [PATCH] Added recursion

---
 README.md                                     |   1 +
 .../power or exponentiation.cpp               |  25 ++++
 Recursion/1. Basics/firstOcc/firstOcc.cpp     |  40 +++++++
 .../1. Basics/inc dec order/print rec.cpp     |  44 +++++++
 .../bubble sort rec/bubble sort rec.cpp       |  49 ++++++++
 .../inv count/inv count.cpp                   |  58 ++++++++++
 .../quick sort/quick sort.cpp                 |  51 +++++++++
 .../2048 problem recursion.cpp                |  39 +++++++
 .../friends pairing problem.cpp               |  36 ++++++
 .../Ladder problem/Ladder problem.cpp         |  25 ++++
 .../Ladder problem/Ladder problem2.cpp        |  27 +++++
 .../binaryStringswithoutcon1s.cpp             |  41 +++++++
 .../place the tiles/place the tiles2.cpp      |  22 ++++
 .../replace pi/replace pi.cpp                 |  36 ++++++
 .../string to integer recursion.cpp           |  19 ++++
 .../tower of hanoi/tower of hanoi.cpp         |  17 +++
 .../1. more intuitive.cpp                     |  34 ++++++
 .../2. using bitmasking.cpp                   |  26 +++++
 .../intuitive practice.cpp                    |  31 +++++
 .../using rec 2.cpp                           |  45 ++++++++
 .../using rec.cpp                             |  38 +++++++
 .../balanced brackets.cpp                     |  30 +++++
 .../4. Subset Based/3. 01 Knapsack/input.txt  |   3 +
 .../4. Subset Based/3. 01 Knapsack/output.txt |   1 +
 .../3. 01 Knapsack/practice.cpp               |  47 ++++++++
 .../using bitmasking practice.cpp             |  49 ++++++++
 .../3. 01 Knapsack/using bitmasking.cpp       |  48 ++++++++
 .../3. 01 Knapsack/using rec.cpp              |  62 ++++++++++
 .../4. Keypad Problem/4. Keypad Problem.cpp   |  60 ++++++++++
 .../4. Keypad Problem/pratice.cpp             |  38 +++++++
 .../5. ACODE String Generation/ACODE.cpp      |  53 +++++++++
 .../6. Sum it up/sum it up.cpp                |  50 ++++++++
 .../1. Rat in a maze/Rat in a maze.cpp        |  67 +++++++++++
 .../Permutations of a string.cpp              |  28 +++++
 .../Using set STL.cpp                         |  41 +++++++
 .../5. Backtracking/3. N queens/N queens.cpp  |  91 +++++++++++++++
 .../3. N queens/bitmasking approach.cpp       |  27 +++++
 .../3. N queens/bitset approach.cpp           |  29 +++++
 .../4. Sudoku Solver/Sudoku Solver.cpp        | 107 ++++++++++++++++++
 39 files changed, 1535 insertions(+)
 create mode 100644 Recursion/1. Basics/Modular exponentiation/power or exponentiation.cpp
 create mode 100644 Recursion/1. Basics/firstOcc/firstOcc.cpp
 create mode 100644 Recursion/1. Basics/inc dec order/print rec.cpp
 create mode 100644 Recursion/2. Implementation based/bubble sort rec/bubble sort rec.cpp
 create mode 100644 Recursion/2. Implementation based/inv count/inv count.cpp
 create mode 100644 Recursion/2. Implementation based/quick sort/quick sort.cpp
 create mode 100644 Recursion/3. Quick Thinking/2048 problem recursion/2048 problem recursion.cpp
 create mode 100644 Recursion/3. Quick Thinking/Friends pairing problem/friends pairing problem.cpp
 create mode 100644 Recursion/3. Quick Thinking/Ladder problem/Ladder problem.cpp
 create mode 100644 Recursion/3. Quick Thinking/Ladder problem/Ladder problem2.cpp
 create mode 100644 Recursion/3. Quick Thinking/binaryStringswithoutcon1s/binaryStringswithoutcon1s.cpp
 create mode 100644 Recursion/3. Quick Thinking/place the tiles/place the tiles2.cpp
 create mode 100644 Recursion/3. Quick Thinking/replace pi/replace pi.cpp
 create mode 100644 Recursion/3. Quick Thinking/stringToInt/string to integer recursion.cpp
 create mode 100644 Recursion/3. Quick Thinking/tower of hanoi/tower of hanoi.cpp
 create mode 100644 Recursion/4. Subset Based/1. subset or subsequences gen recursion/1. more intuitive.cpp
 create mode 100644 Recursion/4. Subset Based/1. subset or subsequences gen recursion/2. using bitmasking.cpp
 create mode 100644 Recursion/4. Subset Based/1. subset or subsequences gen recursion/intuitive practice.cpp
 create mode 100644 Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec 2.cpp
 create mode 100644 Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec.cpp
 create mode 100644 Recursion/4. Subset Based/2. balanced brackets/balanced brackets.cpp
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/input.txt
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/output.txt
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/practice.cpp
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking practice.cpp
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking.cpp
 create mode 100644 Recursion/4. Subset Based/3. 01 Knapsack/using rec.cpp
 create mode 100644 Recursion/4. Subset Based/4. Keypad Problem/4. Keypad Problem.cpp
 create mode 100644 Recursion/4. Subset Based/4. Keypad Problem/pratice.cpp
 create mode 100644 Recursion/4. Subset Based/5. ACODE String Generation/ACODE.cpp
 create mode 100644 Recursion/4. Subset Based/6. Sum it up/sum it up.cpp
 create mode 100644 Recursion/5. Backtracking/1. Rat in a maze/Rat in a maze.cpp
 create mode 100644 Recursion/5. Backtracking/2. Permutations of a string/Permutations of a string.cpp
 create mode 100644 Recursion/5. Backtracking/2. Permutations of a string/Using set STL.cpp
 create mode 100644 Recursion/5. Backtracking/3. N queens/N queens.cpp
 create mode 100644 Recursion/5. Backtracking/3. N queens/bitmasking approach.cpp
 create mode 100644 Recursion/5. Backtracking/3. N queens/bitset approach.cpp
 create mode 100644 Recursion/5. Backtracking/4. Sudoku Solver/Sudoku Solver.cpp

diff --git a/README.md b/README.md
index 60a7097..737347b 100644
--- a/README.md
+++ b/README.md
@@ -8,5 +8,6 @@ Sections
 - Getting started with C++
 - Programming Fundamentals
 - Programming Fundamentals-II
+- Recursion
 
 
diff --git a/Recursion/1. Basics/Modular exponentiation/power or exponentiation.cpp b/Recursion/1. Basics/Modular exponentiation/power or exponentiation.cpp
new file mode 100644
index 0000000..895c16e
--- /dev/null
+++ b/Recursion/1. Basics/Modular exponentiation/power or exponentiation.cpp	
@@ -0,0 +1,25 @@
+// exponentiation using recursion
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int power(int a, int b){
+	// Base case 
+	if(b==0) return 1;
+	return a*power(a,b-1);
+}
+
+int powerFast(int a, int b){
+	// Base case
+	if(b==0) return 1;
+	if(b&1) return a*power(a, b/2)*power(a, b/2);
+	else return power(a, b/2)*power(a, b/2);
+}
+
+int main(){
+	int a, b; cin>>a>>b;
+	cout<<power(a,b)<<endl;
+	cout<<powerFast(a,b)<<endl;
+}
+
+
diff --git a/Recursion/1. Basics/firstOcc/firstOcc.cpp b/Recursion/1. Basics/firstOcc/firstOcc.cpp
new file mode 100644
index 0000000..d87308c
--- /dev/null
+++ b/Recursion/1. Basics/firstOcc/firstOcc.cpp	
@@ -0,0 +1,40 @@
+// first Occurence of key in an array
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int firstOcc(int arr[], int s, int e, int key){
+	// Base case
+	if(s==e) return -1;
+	if(arr[s]==key) return s;
+	
+	return firstOcc(arr, s+1, e, key);
+}
+
+void allOcc(int arr[], int s, int e, int key){
+	// Base case
+	if(s==e) return;
+	else if(arr[s]==key){
+		cout<<s<<" ";
+		allOcc(arr, s+1, e, key);
+	}
+	else{
+		allOcc(arr, s+1, e, key);
+	}
+}
+
+
+int main(){
+	int arr[]={1,2,3,7,4,5,6,7,10};
+	int key=7;
+	int n=sizeof(arr)/sizeof(arr[0]);
+	cout<<firstOcc(arr, 0, n, key)<<endl;
+	allOcc(arr, 0, n, key);
+}
+
+
diff --git a/Recursion/1. Basics/inc dec order/print rec.cpp b/Recursion/1. Basics/inc dec order/print rec.cpp
new file mode 100644
index 0000000..2668d0d
--- /dev/null
+++ b/Recursion/1. Basics/inc dec order/print rec.cpp	
@@ -0,0 +1,44 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void printDec(int n){
+	cout<<n<<" ";
+	// Base Case 
+	if(n==1) return;
+	printDec(n-1);
+}
+
+//void printDec(int n){
+//	// Base Case 
+//	if(n==0) return;
+//	
+//	cout<<n<<" ";
+//	printDec(n-1);
+//}
+
+
+void printInc(int n){
+	// Base Case
+	if(n==1){
+		cout<<n<<" ";
+		return;
+	}
+	printInc(n-1);
+	cout<<n<<" ";
+}
+
+//void printInc(int n){
+//	// Base Case
+//	if(n==0){
+//		return;
+//	}
+//	printInc(n-1);
+//	cout<<n<<" ";
+//}
+
+int main(){
+	printDec(5); cout<<endl;
+	printInc(5);
+}
+
+
diff --git a/Recursion/2. Implementation based/bubble sort rec/bubble sort rec.cpp b/Recursion/2. Implementation based/bubble sort rec/bubble sort rec.cpp
new file mode 100644
index 0000000..ec83fb5
--- /dev/null
+++ b/Recursion/2. Implementation based/bubble sort rec/bubble sort rec.cpp	
@@ -0,0 +1,49 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+bool compare(int a, int b){
+	return a<b;
+}
+
+void bubbleSort(int arr[], int n){
+	//Base case
+	if(n==1){
+		return;
+	}
+	
+	for(int i=0; i<n-1; i++){
+		if(compare(arr[i+1], arr[i])){
+			swap(arr[i+1], arr[i]);
+		}
+	}
+	
+	bubbleSort(arr, n-1);
+	
+}
+
+// fully recursive
+void bubbleSortRec(int arr[], int i, int n){
+	// Base case
+	if(n==1) return;
+	if(i==n-1){
+		//single pass of the current array has been done
+		return bubbleSortRec(arr, 0, n-1);
+	}
+	
+	if(compare(arr[i+1], arr[i])){
+		swap(arr[i+1], arr[i]);
+	}
+	bubbleSortRec(arr, i+1, n);
+}
+
+
+int main(){
+	int arr[]={1,4,7,3,9,10,6};
+	int n=sizeof(arr)/sizeof(arr[0]);
+	bubbleSortRec(arr,0, n);
+	for(int i=0; i<n; i++){
+		cout<<arr[i]<<" ";
+	}
+}
+
+
diff --git a/Recursion/2. Implementation based/inv count/inv count.cpp b/Recursion/2. Implementation based/inv count/inv count.cpp
new file mode 100644
index 0000000..bc758db
--- /dev/null
+++ b/Recursion/2. Implementation based/inv count/inv count.cpp	
@@ -0,0 +1,58 @@
+#include<bits/stdc++.h>
+#include<vector>
+#define MAX 100000
+using namespace std;
+int inv=0;
+
+void merge(vector<int> &a, vector<int> &b, vector<int> &toreturn){ //You are given two sorted arrays A and B. You want to merge these arrays and return a sorted vector will elements from both arrays.
+    int apointer = 0, bpointer = 0; //point to the first element in the vectors
+    //That hasn't been taken yet
+    while(apointer<a.size() && bpointer<b.size()){
+        if(a[apointer]<=b[bpointer]){
+            toreturn.push_back(a[apointer++]);
+        }
+        else{ //b[bpointer] < a[apointer]
+            inv += (a.size() - apointer);
+            toreturn.push_back(b[bpointer++]);
+        }
+    }
+    while(apointer<a.size()) toreturn.push_back(a[apointer++]);
+    while(bpointer<b.size()) toreturn.push_back(b[bpointer++]);
+}
+
+void ms(int arr[], int s, int e){
+//	cout<<s<<" "<<e<<endl;
+	if(s==e){// there is only one or no element
+		return;
+	}
+	int mid = (s+e)/2;
+	ms(arr, s, mid);
+	ms(arr, mid+1, e);
+	
+	// Now arr[] has two sorted parts inside it. 
+	// We have to take them out, merge the two parts and 
+	// then resassign the values to arr[]
+	vector<int> a,b;
+	for(int i=s; i<=mid; i++) a.push_back(arr[i]);
+	for(int i=mid+1; i<=e; i++) b.push_back(arr[i]);  
+	
+	vector<int> temp;
+	merge(a,b, temp);
+	for(int i=0; i<temp.size(); i++){
+		arr[s+i] = temp[i];
+	}
+}
+
+
+
+int main(){
+	int n; cin>>n; 
+	int arr[n];
+	for(int i=0; i<n; i++) cin>>arr[i];
+	ms(arr, 0, n-1);
+	for(int i=0; i<n; i++) cout<<arr[i]<<" ";
+	cout<<endl;
+	cout<<"Inv = "<<inv<<endl;
+}
+
+
diff --git a/Recursion/2. Implementation based/quick sort/quick sort.cpp b/Recursion/2. Implementation based/quick sort/quick sort.cpp
new file mode 100644
index 0000000..fa47858
--- /dev/null
+++ b/Recursion/2. Implementation based/quick sort/quick sort.cpp	
@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int partition(int arr[], int s, int e){
+	// inplace partition
+	int pivot = e;
+	int i=s-1;
+	
+	for(int j=s; j<e; j++){
+		
+		if(arr[j]<=arr[pivot]){
+			i++;
+			swap(arr[i], arr[j]);
+		}
+		if(arr[j]>arr[pivot]){
+			// j already increases
+		}
+		
+	}
+	// Placing pivot element at correct place
+	swap(arr[i+1], arr[pivot]);
+	
+	return i+1;
+	
+}
+
+void quicksort(int arr[], int s, int e){
+	// Base Case
+	if(s>=e){
+		// One or no element is present in the array.
+		// So it is sorted.
+		return;
+	}
+	int p=partition(arr, s, e);
+	
+	quicksort(arr, s, p-1);
+	quicksort(arr, p+1, e);
+}
+
+int main(){
+	int arr[]={2,7,8,6,1,5,4};
+	int n = sizeof(arr)/sizeof(arr[0]);
+	
+	quicksort(arr, 0, n-1);
+	
+	for(int i=0; i<n; i++){
+		cout<<arr[i]<<" ";
+	}
+}
+
+
diff --git a/Recursion/3. Quick Thinking/2048 problem recursion/2048 problem recursion.cpp b/Recursion/3. Quick Thinking/2048 problem recursion/2048 problem recursion.cpp
new file mode 100644
index 0000000..3453b2f
--- /dev/null
+++ b/Recursion/3. Quick Thinking/2048 problem recursion/2048 problem recursion.cpp	
@@ -0,0 +1,39 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+void print(int n){
+	
+	switch(n){
+		case 0: cout<<"zero"; break;
+		case 1: cout<<"one"; break;
+		case 2: cout<<"two"; break;
+		case 3: cout<<"three"; break;
+		case 4: cout<<"four"; break;
+		case 5: cout<<"five"; break;
+		case 6: cout<<"six"; break;
+		case 7: cout<<"seven"; break;
+		case 8: cout<<"eight"; break;
+		case 9: cout<<"nine"; break;
+		default: cout<<"error"; 
+	}
+}
+
+void fun(int n){
+	// Base case
+	if(n==0) return;
+	
+	fun(n/10);
+	print(n%10); cout<<" ";
+}
+
+int main(){
+	int n=204478;
+	fun(n);
+}
+
+
diff --git a/Recursion/3. Quick Thinking/Friends pairing problem/friends pairing problem.cpp b/Recursion/3. Quick Thinking/Friends pairing problem/friends pairing problem.cpp
new file mode 100644
index 0000000..a9bb243
--- /dev/null
+++ b/Recursion/3. Quick Thinking/Friends pairing problem/friends pairing problem.cpp	
@@ -0,0 +1,36 @@
+// Friends pairing problem
+
+// Given N, frinds who want to go to a party on bikes.
+// Each person can go single, or as a couple. Find the number of ways in which N friends can go to the party.
+
+#include<bits/stdc++.h>
+#define MAX 100000
+using namespace std;
+
+int noOfWays(int n){
+	// Base Case
+	if(n==1 || n==0) return 1;
+	if(n==2) return 2;
+	
+	return noOfWays(n-1)+(n-1)*noOfWays(n-2);
+}
+
+int topDown(int n, int dp[]){
+	// Lookup
+	if(dp[n]!=-1){
+		return dp[n];
+	}
+	
+	return dp[n]=topDown(n-1, dp) + (n-1)*topDown(n-2, dp);
+}
+
+int main(){
+	int dp[MAX];
+	std::fill_n(dp, MAX, -1);
+	dp[0]=1; dp[1]=1; dp[2]=2;
+	int n; cin>>n;
+	cout<<noOfWays(n)<<endl;
+	cout<<topDown(n, dp);
+}
+
+
diff --git a/Recursion/3. Quick Thinking/Ladder problem/Ladder problem.cpp b/Recursion/3. Quick Thinking/Ladder problem/Ladder problem.cpp
new file mode 100644
index 0000000..6aece2c
--- /dev/null
+++ b/Recursion/3. Quick Thinking/Ladder problem/Ladder problem.cpp	
@@ -0,0 +1,25 @@
+//Total n steps to be taken.
+// at one time, we can take 1,2,3 steps. How many ways?
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int main(){
+	int dp[MAX]{0};
+	dp[1]=1; dp[2]=2; dp[3]=4;
+	
+	for(int i=4; i<MAX; i++){
+		dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
+	}
+	
+	int n; cin>>n;
+	cout<<dp[n];
+	
+}
+
+
diff --git a/Recursion/3. Quick Thinking/Ladder problem/Ladder problem2.cpp b/Recursion/3. Quick Thinking/Ladder problem/Ladder problem2.cpp
new file mode 100644
index 0000000..d089016
--- /dev/null
+++ b/Recursion/3. Quick Thinking/Ladder problem/Ladder problem2.cpp	
@@ -0,0 +1,27 @@
+//Total n steps to be taken.
+// at one time, we can take 1,2,3 steps. How many ways?
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int count(int n){
+	// Base Case
+	if(n==1 || n==0) return 1;
+	if(n<0) return 0;
+	
+	return count(n-1)+count(n-2)+count(n-3);
+}
+
+int main(){
+	
+	int n; cin>>n;
+	cout<<count(n);
+	
+}
+
+
diff --git a/Recursion/3. Quick Thinking/binaryStringswithoutcon1s/binaryStringswithoutcon1s.cpp b/Recursion/3. Quick Thinking/binaryStringswithoutcon1s/binaryStringswithoutcon1s.cpp
new file mode 100644
index 0000000..8ec3897
--- /dev/null
+++ b/Recursion/3. Quick Thinking/binaryStringswithoutcon1s/binaryStringswithoutcon1s.cpp	
@@ -0,0 +1,41 @@
+// count binary strings of length N with no consecutive 1's
+
+#include<bits/stdc++.h>
+#define MAX 100000
+using namespace std;
+
+int count(int n){
+	if(n==1) return 2;
+	if(n==2) return 3;
+		
+	int a=2, b=3;
+	for(int i=2; i<n; i++){
+		int temp = b;
+		b+=a;
+		a=temp;
+	}
+	return b;
+}
+
+//There are two possiblities:
+//In the last bit we can have 1 or 0
+//If 0 is present in the last bit, 
+//then we must return the count of numbers without consecutive 1's in the the remaing n-1 places
+//But if the last bit is 1, then the next bit must be 0. 
+//Thus, the system would behave normally after 2 places. Thus, we must return the count of numbers without consecutive 1's in the the remaing n-2 places
+
+int count2(int n){
+	if(n==1) return 2;
+	if(n==2) return 3;
+	
+	return count2(n-1)+count(n-2);
+}
+
+int main(){
+	int n; cin>>n;
+	cout<<count(n)<<endl;
+	cout<<count2(n)<<endl;
+	
+}
+
+
diff --git a/Recursion/3. Quick Thinking/place the tiles/place the tiles2.cpp b/Recursion/3. Quick Thinking/place the tiles/place the tiles2.cpp
new file mode 100644
index 0000000..08a7134
--- /dev/null
+++ b/Recursion/3. Quick Thinking/place the tiles/place the tiles2.cpp	
@@ -0,0 +1,22 @@
+// Place the tiles
+// Given a wall of size of 4 X N, and tiles of size (1,4) and (4,1).
+// In how many ways you can build the wall?
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int noOfWays(int n){
+	// Base Case
+	if(n==1 || n==2 || n==3) return 1;
+	if(n==4) return 2;
+	
+	return noOfWays(n-1)+noOfWays(n-4);
+	
+}
+  
+int main(){
+	int n; cin>>n;
+	cout<<noOfWays(n)<<endl;
+}
+
+
diff --git a/Recursion/3. Quick Thinking/replace pi/replace pi.cpp b/Recursion/3. Quick Thinking/replace pi/replace pi.cpp
new file mode 100644
index 0000000..8702ad3
--- /dev/null
+++ b/Recursion/3. Quick Thinking/replace pi/replace pi.cpp	
@@ -0,0 +1,36 @@
+// Replace "pi" with 3.14
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void replace(char a[], int s, int e){
+	// Base case
+	if(s>=e) return;
+	
+	int i=s;
+	for(i=s; i<e-1; i++){
+		if(a[i]=='p' && a[i+1]=='i'){
+			// Replacing 
+			for(int j=e; j>i+1; j--){
+				a[j+2] = a[j];
+			}
+			a[i]='3'; a[i+1]='.'; a[i+2]='1'; a[i+3]='4';
+			
+			replace(a, i+4, e+4);
+			break;
+		}
+	}
+	
+	
+}
+
+int main(){
+	char a[100]="xpighpilmpipi";
+	
+	int n=0; while(a[n]!='\0') n++;
+	
+	replace(a,0, n);
+	cout<<a;
+}
+
+
diff --git a/Recursion/3. Quick Thinking/stringToInt/string to integer recursion.cpp b/Recursion/3. Quick Thinking/stringToInt/string to integer recursion.cpp
new file mode 100644
index 0000000..7bb31e1
--- /dev/null
+++ b/Recursion/3. Quick Thinking/stringToInt/string to integer recursion.cpp	
@@ -0,0 +1,19 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int stringToInt(char a[], int n){
+	// Base Case
+	if(n<0) return 0;
+	int digit = a[n]-'0';
+	return (stringToInt(a, n-1)*10)+digit;
+	
+}
+
+int main(){
+	char a[]="1234";
+	int n = strlen(a);
+	int ans = stringToInt(a, n-1);
+	cout<<ans;
+}
+
+
diff --git a/Recursion/3. Quick Thinking/tower of hanoi/tower of hanoi.cpp b/Recursion/3. Quick Thinking/tower of hanoi/tower of hanoi.cpp
new file mode 100644
index 0000000..2dd5e40
--- /dev/null
+++ b/Recursion/3. Quick Thinking/tower of hanoi/tower of hanoi.cpp	
@@ -0,0 +1,17 @@
+// tower of Hanoi
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int move(int n){
+	if(n==1) return 1;
+	
+	return 2*move(n-1)+1;
+}
+
+int main(){
+	int n; cin>>n;
+	cout<<move(n)<<endl;
+}
+
+
diff --git a/Recursion/4. Subset Based/1. subset or subsequences gen recursion/1. more intuitive.cpp b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/1. more intuitive.cpp
new file mode 100644
index 0000000..75f85b2
--- /dev/null
+++ b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/1. more intuitive.cpp	
@@ -0,0 +1,34 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+void generate_subset(char *in, char *out, int i, int j){
+	// Base Case
+	if(in[i]=='\0'){
+		out[j] = '\0';
+		cout<<out<<endl;
+		return;
+	}
+	
+	
+	// Including in[i]
+	out[j] = in[i];
+	generate_subset(in, out, i+1, j+1);
+	
+	
+	// Excluding in[i]
+	generate_subset(in, out, i+1, j);
+}
+
+int main(){
+	char in[] = "abc";
+	char out[10] = "";
+	
+	generate_subset(in, out, 0, 0);
+}
+
+
diff --git a/Recursion/4. Subset Based/1. subset or subsequences gen recursion/2. using bitmasking.cpp b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/2. using bitmasking.cpp
new file mode 100644
index 0000000..80f4125
--- /dev/null
+++ b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/2. using bitmasking.cpp	
@@ -0,0 +1,26 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+int main(){
+	string s; cin>>s;
+	
+	int n = s.size();
+	
+	for(int i=0; i<(1<<n); i++){
+		
+		for(int j=0; j<n; j++){
+			if(i&(1<<j)){
+				cout<<s[j];
+			}
+		}
+		cout<<endl;
+	}
+	
+}
+
+
diff --git a/Recursion/4. Subset Based/1. subset or subsequences gen recursion/intuitive practice.cpp b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/intuitive practice.cpp
new file mode 100644
index 0000000..87baebc
--- /dev/null
+++ b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/intuitive practice.cpp	
@@ -0,0 +1,31 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define pb push_back
+#define MAX 100005
+#define mod 1000000007 // 1e9+7
+#define inf 1e18
+using namespace std;
+
+void generate_subset(char in[], char out[], int i, int j) {
+
+	if (in[i] == '\0') {
+		out[j] = '\0';
+		cout << out << endl;
+		return;
+	}
+
+	// including in[i]
+	out[j] = in[i];
+	generate_subset(in, out, i + 1, j + 1);
+
+
+	// Excluding in[i]
+	generate_subset(in, out, i + 1, j);
+}
+
+int main() {
+	char in[] = "abc";
+	char out[10] = "";
+
+	generate_subset(in, out, 0, 0);
+}
diff --git a/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec 2.cpp b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec 2.cpp
new file mode 100644
index 0000000..ba9b74b
--- /dev/null
+++ b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec 2.cpp	
@@ -0,0 +1,45 @@
+// The idea is to fix a prefix, generate all subsets beginning with current prefix. 
+/// After all subsets with a prefix are generated, replace last character with one of the remaining characters
+// CPP program to generate power set 
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// str : Stores input string 
+// curr : Stores current subset 
+// index : Index in current subset, curr 
+void powerSet(string str, int index = -1, 
+			string curr = "") 
+{ 
+	int n = str.length(); 
+
+	// base case 
+	if (index == n) 
+		return; 
+
+	// First print current subset 
+	cout << curr << "\n"; 
+
+	// Try appending remaining characters 
+	// to current subset 
+	for (int i = index + 1; i < n; i++) { 
+
+		curr += str[i]; 
+		powerSet(str, i, curr); 
+
+		// Once all subsets beginning with 
+		// initial "curr" are printed, remove 
+		// last character to consider a different 
+		// prefix of subsets. 
+		curr.erase(curr.size() - 1); 
+	} 
+	return; 
+} 
+
+// Driver code 
+int main() 
+{ 
+	string str = "abc"; 
+	powerSet(str); 
+	return 0; 
+} 
+
diff --git a/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec.cpp b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec.cpp
new file mode 100644
index 0000000..15cc427
--- /dev/null
+++ b/Recursion/4. Subset Based/1. subset or subsequences gen recursion/using rec.cpp	
@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+//void generateSubsets(string first, string st, int s, int e){
+//	// Base Case
+//	if(s==e){
+//		cout<<first<<endl;
+//		cout<<first+st[s]<<endl;
+//		return;
+//	}
+//	
+//	generateSubsets(st, s+1, e);
+//	generateSubsets(st[s],  st, s+1, e);
+//	
+//}
+
+void generateSubsets(string str, int s, string curr){
+	// Base Case
+	if(s==str.length()){
+		cout<<curr<<endl;
+		return;
+	}
+	
+	generateSubsets(str, s+1, curr);
+	generateSubsets(str, s+1, curr+str[s]);
+	
+}
+
+int main(){
+	string str; cin>>str;
+	
+	int n = str.size();
+	
+	generateSubsets(str, 0, "");
+	
+}
+
+
diff --git a/Recursion/4. Subset Based/2. balanced brackets/balanced brackets.cpp b/Recursion/4. Subset Based/2. balanced brackets/balanced brackets.cpp
new file mode 100644
index 0000000..4d7f6bf
--- /dev/null
+++ b/Recursion/4. Subset Based/2. balanced brackets/balanced brackets.cpp	
@@ -0,0 +1,30 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+void brackets(string s, int count_o, int count_c, int n){
+	// Base Case
+	if(count_c==n){
+		cout<<s<<endl;
+		return; 
+	}
+	
+	if(count_o<n){
+		brackets(s+"(", count_o+1, count_c, n);
+	}
+	if(count_c<count_o){
+		brackets(s+")", count_o, count_c+1, n);
+	}
+}
+
+int main(){
+	int n; cin>>n;
+	string s;
+	brackets(s, 0, 0, n);
+}
+
+
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/input.txt b/Recursion/4. Subset Based/3. 01 Knapsack/input.txt
new file mode 100644
index 0000000..f374e2a
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/input.txt	
@@ -0,0 +1,3 @@
+4 7
+40 20 35 100
+1 2 3 4
\ No newline at end of file
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/output.txt b/Recursion/4. Subset Based/3. 01 Knapsack/output.txt
new file mode 100644
index 0000000..a762560
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/output.txt	
@@ -0,0 +1 @@
+160
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/practice.cpp b/Recursion/4. Subset Based/3. 01 Knapsack/practice.cpp
new file mode 100644
index 0000000..7e77eec
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/practice.cpp	
@@ -0,0 +1,47 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define pb push_back
+#define MAX 100005
+#define mod 1000000007 // 1e9+7
+#define inf 1e18
+using namespace std;
+
+int price[MAX], weight[MAX], n, capacity, maxP = 0;
+
+void subset(int i, int cw, int cp) {
+
+	//Base Case
+	if (i == n) {
+		if (cw <= capacity) {
+			maxP = max(maxP, cp);
+			//cout << maxP << endl;
+		}
+		return;
+	}
+
+	// Including price and weight[i]
+	subset(i + 1, cw + weight[i], cp + price[i]);
+
+	//Excluding price and weight[i]
+	subset(i + 1, cw, cp);
+
+}
+
+int main() {
+
+#ifndef ONLINE_JUDGE
+	freopen("input.txt", "r", stdin);
+	freopen("output.txt", "w", stdout);
+#endif
+
+	ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+
+	cin >> n >> capacity;
+
+	for (int i = 0; i < n; i++) cin >> price[i];
+	for (int i = 0; i < n; i++) cin >> weight[i];
+
+	subset(0, 0, 0);
+	cout << maxP << endl;
+}
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking practice.cpp b/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking practice.cpp
new file mode 100644
index 0000000..696b07c
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking practice.cpp	
@@ -0,0 +1,49 @@
+// Using bitmasking
+
+#include<bits/stdc++.h>
+#define ll long long
+#define pb push_back
+#define MAX 100005
+#define mod 1000000007 // 1e9+7
+#define inf 1e18
+using namespace std;
+
+int price[MAX], weight[MAX], n, capacity, maxP;
+
+void solve() {
+
+	for (int mask = 1; mask < 1 << n; mask++) {
+		int cp = 0, cwt = 0;
+		for (int i = 0; i < n; i++) {
+			if (mask & 1 << i) {
+				cwt += weight[i];
+				cp += price[i];
+			}
+		}
+
+		if (cwt <= capacity) {
+			maxP = max(cp, maxP);
+		}
+	}
+
+}
+
+int main() {
+
+#ifndef ONLINE_JUDGE
+	freopen("input.txt", "r", stdin);
+	freopen("output.txt", "w", stdout);
+#endif
+
+	ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+
+	cin >> n >> capacity;
+
+	for (int i = 0; i < n; i++) cin >> price[i];
+	for (int i = 0; i < n; i++) cin >> weight[i];
+
+
+	solve();
+	cout << maxP << endl;
+}
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking.cpp b/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking.cpp
new file mode 100644
index 0000000..d5e8266
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/using bitmasking.cpp	
@@ -0,0 +1,48 @@
+// Time O(n*2^n)
+
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 1005
+using namespace std;
+
+void solve(){
+	
+	int n; cin>>n;
+	int capacity, maxPrice=INT_MIN; cin>>capacity;
+	
+	int price[MAX]={0}, weight[MAX]={0};
+	
+	for(int i=0; i<n; i++) cin>>price[i];
+	for(int i=0; i<n; i++) cin>>weight[i];
+	
+	for(int mask=0; mask<(1<<n); mask++){
+		int curr_price=0;
+		int curr_weight=0;
+		
+		for(int i=0; i<n; i++){
+			if(mask&(1<<i)){
+				curr_price += price[i];
+				curr_weight += weight[i];
+			}
+		}
+		
+		if(curr_weight<=capacity){
+			maxPrice = max(maxPrice, curr_price);
+		}
+		
+	}
+	
+	cout<<maxPrice<<endl;
+}
+
+int main(){
+	int t; cin>>t;
+	while(t--){
+		solve();
+	}
+}
+
+
diff --git a/Recursion/4. Subset Based/3. 01 Knapsack/using rec.cpp b/Recursion/4. Subset Based/3. 01 Knapsack/using rec.cpp
new file mode 100644
index 0000000..f024c3f
--- /dev/null
+++ b/Recursion/4. Subset Based/3. 01 Knapsack/using rec.cpp	
@@ -0,0 +1,62 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 1005
+using namespace std;
+
+int capacity;
+int n, maxSum = INT_MIN;
+int price[MAX] = {0}, weight[MAX] = {0};
+
+void solve(int *in, int *out, int i = 0, int j = 0, int cwt = 0, int cp = 0) {
+
+	// Base Case
+	if (i == n) {
+		if (cwt <= capacity) {
+			maxSum = max(maxSum, cp);
+			//cout << maxSum << endl;
+		}
+		return;
+	}
+
+	// Including in[i]
+	out[j] = in[i];
+	if ( (cwt + in[i]) <= capacity)
+		solve(in, out, i + 1, j + 1, cwt + in[i], cp + price[i]);
+
+	// Excluding in[i]
+	solve(in, out, i + 1, j, cwt, cp);
+
+}
+
+
+int main() {
+
+#ifndef ONLINE_JUDGE
+	freopen("input.txt", "r", stdin);
+	freopen("output.txt", "w", stdout);
+#endif
+
+	int t;
+	cin >> t;
+	while (t--) {
+		maxSum = INT_MIN;
+		cin >> n;
+		cin >> capacity;
+		int out[MAX] = {0};
+
+		for (int i = 0; i < n; i++) cin >> price[i];
+		for (int i = 0; i < n; i++) cin >> weight[i];
+
+		// weight will be my input array
+		solve(weight, out);
+
+		if (maxSum != INT_MIN) cout << maxSum << endl;
+		else cout << "0" << endl;
+
+	}
+}
+
+
diff --git a/Recursion/4. Subset Based/4. Keypad Problem/4. Keypad Problem.cpp b/Recursion/4. Subset Based/4. Keypad Problem/4. Keypad Problem.cpp
new file mode 100644
index 0000000..b2a3184
--- /dev/null
+++ b/Recursion/4. Subset Based/4. Keypad Problem/4. Keypad Problem.cpp	
@@ -0,0 +1,60 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+char keypad[][5] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wx", "yz"};
+int counter=0;
+
+
+void subsets(char *in, char *out, int i=0, int j=0){
+	// Base Case
+	// If i reaches end
+	if(in[i]=='\0'){
+		out[j] = '\0';
+		cout<<out<<" "; 
+		
+		counter++;
+		return;
+	}
+	
+	// for every i, I can include either items from keypad[i]
+	// in[i]
+	int number = in[i] - '0'; 
+//	int size = sizeof(keypad[number])/sizeof(keypad[number][0]);
+	
+	// Chooose from Keypad[number]
+	
+//	out[j] = keypad[number][0];
+//	subsets(in, out, i+1, j+1);
+//	
+//	out[j] = keypad[number][1];
+//	subsets(in, out, i+1, j+1);
+//	
+//	out[j] = keypad[number][2];
+//	subsets(in, out, i+1, j+1);
+	
+	
+	// For general case with any number of characters
+	
+	for(int i2=0; keypad[number][i2]!='\0'; i2++){
+		out[j]  = keypad[number][i2];
+		subsets(in, out, i+1, j+1);
+	}
+	
+}
+
+
+int main(){
+	char in[MAX]; cin>>in;
+	
+	char out[MAX];
+	
+	subsets(in, out);
+	cout<<endl<<counter;
+}
+
+
diff --git a/Recursion/4. Subset Based/4. Keypad Problem/pratice.cpp b/Recursion/4. Subset Based/4. Keypad Problem/pratice.cpp
new file mode 100644
index 0000000..51c1ab6
--- /dev/null
+++ b/Recursion/4. Subset Based/4. Keypad Problem/pratice.cpp	
@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define pb push_back
+#define MAX 100005
+#define mod 1000000007 // 1e9+7
+#define inf 1e18
+using namespace std;
+
+char keypad[][5] = {"", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wx", "yz"};
+int counter = 0;
+
+void subsets(char in[], char out[], int i = 0, int j = 0) {
+
+	// Base case
+	if (in[i] == '\0') {
+		out[j] = '\0';
+		cout << out << endl;
+		return;
+	}
+	int key = in[i] - '0';
+	// I will choose key-1
+	for (int k = 0; keypad[key - 1][k] != '\0'; k++) {
+
+		//Including keypad[key-1][k]
+		out[j] = keypad[key - 1][k];
+		subsets(in, out, i + 1, j + 1);
+	}
+
+}
+
+int main() {
+	char in[MAX] = "23";
+
+	char out[MAX];
+
+	subsets(in, out);
+	cout << endl << counter;
+}
\ No newline at end of file
diff --git a/Recursion/4. Subset Based/5. ACODE String Generation/ACODE.cpp b/Recursion/4. Subset Based/5. ACODE String Generation/ACODE.cpp
new file mode 100644
index 0000000..d7c422a
--- /dev/null
+++ b/Recursion/4. Subset Based/5. ACODE String Generation/ACODE.cpp	
@@ -0,0 +1,53 @@
+#include<bits/stdc++.h>
+#include<climits>
+#include<algorithm>
+#include<math.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+void subsets(char *in, char *out, int i=0, int j=0){
+	// Base Case
+	if(in[i]=='\0'){
+		out[j] = '\0';
+		cout<<out<<endl;
+		return;
+	}
+	
+	// Including i
+	int digit = in[i] - '0';
+	char ch = digit + 'A' - 1;
+	out[j] = ch; 
+	subsets(in, out, i+1, j+1);
+	
+	// Inlcuding i, i+1
+	if(in[i+1]!='\0'){
+		int a = in[i]-'0'; int b = in[i+1]-'0';
+		int number = a*10 + b;
+		if(number<=26){
+			out[j] = number + 'A' - 1;
+			subsets(in, out, i+2, j+1);
+		}
+		
+	}
+	
+	
+	
+//	int a = in[i]-'0'; int b = in[i+1]-'0';
+//	int pos = a*10 + b; char ch2 = pos + 'A' - 1; 
+//	if(in[i+1]!='\0' && pos<=26){
+//		out[j] = ch2;
+//		subsets(in, out, i+2, j+1);
+//	}
+	
+}
+
+int main(){
+	
+	char in[MAX]; cin>>in;
+	char out[MAX];
+	
+	subsets(in, out);
+}
+
+
diff --git a/Recursion/4. Subset Based/6. Sum it up/sum it up.cpp b/Recursion/4. Subset Based/6. Sum it up/sum it up.cpp
new file mode 100644
index 0000000..3dad81c
--- /dev/null
+++ b/Recursion/4. Subset Based/6. Sum it up/sum it up.cpp	
@@ -0,0 +1,50 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+
+ll n, target; 
+
+bool solve(int in[], int out[], int i=0, int j=0, int sum=0){
+	
+	// Base Case
+	if(sum==target){
+		// Print the output
+		for(int x=0; x<j; x++){
+			cout<<out[x]<<" ";
+		} cout<<endl;
+		return true;
+	}
+	if(i==n){// input array has been exhausted
+		return false;
+	}
+	if(sum+in[i]>target){
+		return false;
+	}
+	
+	// Rec case
+	
+	// Inlcuding in[i]
+	out[j] = in[i];
+	solve(in, out, i+1, j+1, sum+in[i]);
+	
+	// We will also try the case where we exclude in[i]
+	// excluding in[i]
+	solve(in, out, i+1, j, sum);
+}
+
+int main(){
+	cin>>n;
+	int arr[MAX]={0};
+	for(int i=0; i<n; i++){
+		cin>>arr[i];
+	} sort(arr, arr+n);
+	cin>>target;
+	
+	int out[MAX]={0};
+	
+	solve(arr, out);
+	
+}
+
+
diff --git a/Recursion/5. Backtracking/1. Rat in a maze/Rat in a maze.cpp b/Recursion/5. Backtracking/1. Rat in a maze/Rat in a maze.cpp
new file mode 100644
index 0000000..f9091e2
--- /dev/null
+++ b/Recursion/5. Backtracking/1. Rat in a maze/Rat in a maze.cpp	
@@ -0,0 +1,67 @@
+#include <iostream>
+using namespace std;
+bool ratInMaze(char maze[][1005], int sol[][1005], int i, int j, int m, int n)
+{
+    //Base case
+    if (i == m && j == n)
+    {
+        sol[i][j] = 1;
+        for (int row = 0; row <= m; row++)
+        {
+            for (int col = 0; col <= n; col++)
+            {
+                cout << sol[row][col] << " ";
+            }
+            cout << endl;
+        }
+        cout << endl;
+        return true;
+    }
+
+    //Rat should be inside the maze
+    if (i > m || j > n)
+        return false;
+
+    //Should not encounter a blocked cell
+    if (maze[i][j] == 'X')
+        return false;
+
+    //Recursive case
+    //Assume solution exists through current cell
+    sol[i][j] = 1;
+
+    bool rightSuccess = ratInMaze(maze, sol, i, j + 1, m, n);
+    if (rightSuccess) {
+        return true ;
+    }
+    bool downSuccess  = ratInMaze(maze, sol, i + 1, j, m, n);
+    if (downSuccess) {
+        return true ;
+    }
+
+    //Backtrack
+    sol[i][j] = 0;
+
+    return false;
+
+}
+int main()
+{
+    char maze[1005][1005];
+    int sol[1005][1005] = {0};
+    int m ;     //No of rows
+    int n ;     //No of cols
+    cin >> m >> n;
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            cin >> maze[i][j];
+        }
+    }
+
+    bool ans = ratInMaze(maze, sol, 0, 0, m - 1, n - 1);
+    if (!ans)
+        cout << "-1";
+
+
+    return 0;
+}
\ No newline at end of file
diff --git a/Recursion/5. Backtracking/2. Permutations of a string/Permutations of a string.cpp b/Recursion/5. Backtracking/2. Permutations of a string/Permutations of a string.cpp
new file mode 100644
index 0000000..8243d45
--- /dev/null
+++ b/Recursion/5. Backtracking/2. Permutations of a string/Permutations of a string.cpp	
@@ -0,0 +1,28 @@
+#include<bits/stdc++.h>
+#include<algorithm>
+using namespace std;
+
+void permutation(char *s, int i=0){
+	
+	// Base Case
+	if(s[i]=='\0'){
+		cout<<s<<endl;
+		return;
+	}
+	
+	for(int j=i; s[j]!='\0'; j++){ // For every element in s, 
+		// replace it with s[i] and do permutations for the remaining
+		swap(s[i], s[j]);
+		permutation(s, i+1);
+		// Backtracking - To restore the array
+		swap(s[i], s[j]);
+	}
+}
+
+int main(){
+	char s[100]; cin>>s;
+	
+	permutation(s);
+}
+
+
diff --git a/Recursion/5. Backtracking/2. Permutations of a string/Using set STL.cpp b/Recursion/5. Backtracking/2. Permutations of a string/Using set STL.cpp
new file mode 100644
index 0000000..c65e3d5
--- /dev/null
+++ b/Recursion/5. Backtracking/2. Permutations of a string/Using set STL.cpp	
@@ -0,0 +1,41 @@
+// Permutatins using set STL
+
+#include<bits/stdc++.h>
+#include<set>
+#include<string>
+using namespace std;
+set<string> s;
+
+void permutation(char a[], int i=0){
+	
+	// Base Case
+	if(a[i]=='\0'){
+//		cout<<s<<endl;
+		string t(a);
+		s.insert(t);
+		return;
+	}
+	
+	for(int j=i; a[j]!='\0'; j++){ // For every element in s, 
+		// replace it with s[i] and do permutations for the remaining
+		swap(a[i], a[j]);
+		permutation(a, i+1);
+		// Backtracking - To restore the array
+		swap(a[i], a[j]);
+	}
+}
+
+
+int main(){
+	char a[100]; cin>>a;
+	
+	permutation(a, 0);
+	
+	// Loop over the set
+	for(auto str:s){
+		cout<<str<<endl;
+	}
+	
+}
+
+
diff --git a/Recursion/5. Backtracking/3. N queens/N queens.cpp b/Recursion/5. Backtracking/3. N queens/N queens.cpp
new file mode 100644
index 0000000..4c380bb
--- /dev/null
+++ b/Recursion/5. Backtracking/3. N queens/N queens.cpp	
@@ -0,0 +1,91 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+int counter = 0;
+
+bool isSafe(int board[][20], int i, int j, int n) {
+
+	// check for column
+	for (int row = 0; row < i; row++) {
+		if (board[row][j]) {
+			return 0;
+		}
+	}
+
+	// Check for left diagonal
+	int x = i;
+	int y = j;
+
+	while (x >= 0 && y >= 0) {
+		if (board[x][y]) return 0;
+		x--; y--;
+	}
+
+	// Check for right diagonal
+	x = i;
+	y = j;
+
+	while (x >= 0 && y < n) {
+		if (board[x][y]) return 0;
+		x--; y++;
+	}
+
+	// Therefore, the position is now safe
+	return 1;
+}
+
+// i: starting row
+bool solve(int board[][20], int i, int n) {
+	// Base Case
+	if (i == n) {
+		// print board
+//		for(int row=0; row<n; row++){
+//			for(int col=0; col<n; col++){
+//				if(board[row][col]){
+//					cout<<"Q ";
+//				}
+//				else{
+//					cout<<"_ ";
+//				}
+//			}cout<<endl;
+//		}cout<<endl;
+
+		counter++;
+
+		//return true;
+		// for all configuration
+		return false;  // the control doesnot stop after being able to find one solution
+	}
+
+	// Recursive Case
+	//Place the Qcueen at some place in the ith row where it is safe
+	for (int j = 0; j < n; j++) {
+
+		if (isSafe(board, i, j, n)) {
+			board[i][j] = 1;
+			if (solve(board, i + 1, n)) {
+				return true;
+			}
+			else {
+				board[i][j] = 0; // Backtracking
+			}
+		}
+	}
+
+	// If for loop has been exhausted and we still didnt find a safe position
+	return 0;
+
+}
+
+int main() {
+	int n = 4;
+	//cin>>n;
+
+	int board[20][20] = {0};
+
+	solve(board, 0, n);
+	cout << counter;
+}
+
+
diff --git a/Recursion/5. Backtracking/3. N queens/bitmasking approach.cpp b/Recursion/5. Backtracking/3. N queens/bitmasking approach.cpp
new file mode 100644
index 0000000..21e3225
--- /dev/null
+++ b/Recursion/5. Backtracking/3. N queens/bitmasking approach.cpp	
@@ -0,0 +1,27 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int n;
+int ans = 0, DONE;
+
+
+void solve(int rowMask, int ld, int rd) {
+	if (rowMask == DONE) {
+		ans++;
+		return;
+	}
+
+	int safe = DONE & (~(rowMask | ld | rd));
+	while (safe) {
+		int p = safe & (-safe);
+		safe = safe - p;
+		solve(rowMask | p, (ld | p) <<< 1, (rd | p) >> 1);
+	}
+}
+
+int main() {
+	cin >> n;
+	DONE = ((1 << n) - 1);
+	solve(0, 0, 0);
+	cout << ans << endl;
+}
\ No newline at end of file
diff --git a/Recursion/5. Backtracking/3. N queens/bitset approach.cpp b/Recursion/5. Backtracking/3. N queens/bitset approach.cpp
new file mode 100644
index 0000000..b50de94
--- /dev/null
+++ b/Recursion/5. Backtracking/3. N queens/bitset approach.cpp	
@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+bitset<30> col, d1, d2;
+
+void solve(int r, int n, int &ans) {
+	if (r == n) {
+
+
+		ans++;
+		return;
+	}
+
+	for (int c = 0; c < n; c++) { // Trying to place Queen at every place in the current row
+		if (!col[c] && !d1[r - c + n - 1] && !d2[r + c]) { // If safe
+			col[c] = d1[r - c + n - 1] = d2[r + c] = 1;	//Try placing Queen there
+			solve(r + 1, n, ans);
+			col[c] = d1[r - c + n - 1] = d2[r + c] = 0; // Backtracking
+		}
+	}
+}
+
+int main() {
+	int n = 5;
+	int ans = 0;
+	//int board[20][20] = {0};
+	solve(0, n, ans);
+	cout << ans;
+}
\ No newline at end of file
diff --git a/Recursion/5. Backtracking/4. Sudoku Solver/Sudoku Solver.cpp b/Recursion/5. Backtracking/4. Sudoku Solver/Sudoku Solver.cpp
new file mode 100644
index 0000000..4a9c58c
--- /dev/null
+++ b/Recursion/5. Backtracking/4. Sudoku Solver/Sudoku Solver.cpp	
@@ -0,0 +1,107 @@
+#include<bits/stdc++.h>
+#define ll long long
+#define MAX 100000
+using namespace std;
+int n = 9;
+
+bool isSafe(int board[][9], int i, int j, int num) {
+
+//	// Check in row
+//	for(int col=0; col<n; col++){
+//		if(board[i][col]==num) return 0;
+//	}
+//
+//	// Check in col
+//	for(int row=0; row<n; row++){
+//		if(board[row][j]==num) return 0;
+//	}
+
+	// Check in row or col
+	for (int x = 0; x < n; x++) {
+		if (board[x][j] == num || board[i][x] == num) {
+			return 0;
+		}
+	}
+
+	// Check in subgrid
+	int rn = sqrt(n);
+	int sx = (i / rn) * rn, sy = (j / rn) * rn;
+
+	for (int x = sx; x < sx + rn; x++) {
+		for (int y = sy; y < sy + rn; y++) {
+			if (board[x][y] == num) return 0;
+		}
+	}
+
+	return 1;
+}
+
+bool solve(int board[][9], int i, int j, int n) { // need to solve from i,j
+	// Base Case
+	if (i == n) {
+		// print solution
+		for (int row = 0; row < n; row++) {
+			for (int col = 0; col < n; col++) {
+				cout << board[row][col] << " ";
+			} cout << endl;
+		} cout << endl;
+
+		return true;
+	}
+
+	// Reached row end
+	if (j == n) {
+		return solve(board, i + 1, 0, n); // go to next row
+	}
+
+	// skip pre filled cell
+	if (board[i][j] != 0) {
+		return solve(board, i, j + 1, n); // go to next column
+	}
+
+	// (i, j) is empty
+	//cout<<"empty cell is "<<i<<" "<<j<<endl;
+	// Recursive Case
+	for (int x = 1; x <= n; x++) {
+		if (isSafe(board, i, j, x)) {
+			// Assume
+			board[i][j] = x;
+			bool couldWeSolve = solve(board, i, j + 1, n); // were we able to solve the sudoku by placing x?
+			if (couldWeSolve) {
+				return true;
+			}
+			else board[i][j] = 0;  //Backtracking
+		}
+	}
+
+	return false;
+
+
+}
+
+int main() {
+
+	//cin>>n;
+
+	int board[9][9] = {
+		{5, 3, 0, 0, 7, 0, 0, 0, 0 },
+		{6, 0, 0, 1, 9, 5, 0, 0, 0 },
+		{0, 9, 8, 0, 0, 0, 0, 6, 0 },
+		{8, 0, 0, 0, 6, 0, 0, 0, 3 },
+		{4, 0, 0, 8, 0, 3, 0, 0, 1 },
+		{7, 0, 0, 0, 2, 0, 0, 0, 6 },
+		{0, 6, 0, 0, 0, 0, 2, 8, 0 },
+		{0, 0, 0, 4, 1, 9, 0, 0, 5 },
+		{0, 0, 0, 0, 8, 0, 0, 7, 9 }
+	};
+
+	// for(int i=0; i<n; i++){
+	// 	for(int j=0; j<n; j++){
+	// 		cin>>board[i][j];
+	// 	}
+	// }
+
+	solve(board, 0, 0, n);
+}
+
+