Merge branch 'prathimacode-hub:main' into main

Author: TheDoctor561

Dynamic Programming/Nth Catalan Numbers/Images/catalan-1.png

@@ -0,0 +1,60 @@
+# Nth Catalan Numbers using Dynamic Programming
+Language used : **Python 3**
+
+## 🎯 Aim
+The aim of this script is to find out the n'th catalan numbers using Dynamic Programming.
+
+## 👉 Purpose
+The main purpose of this script is to show the implementation of Dynamic programming on finding out the n'th catalan numbers.
+
+## 📄 Description
+Catalan numbers are defined as a mathematical sequence that consists of positive integers, which can be used to find the number of possibilities of various combinations. 
+
+**Examples:**  
+```
+Input  : k = 12
+Output : 1 1 2 5 14 42 132 429 1430 4862 16796 58786 
+
+Input  : k = 10
+Output : 1 1 2 5 14 42 132 429 1430 4862 
+
+Input  : k = 8
+Output : 1 1 2 5 14 42 132 429 
+```
+
+## 📈 Workflow of the script
+- `catalan` - The main function of the script to find out the catalan numbers using Dynamic Approach.
+- `main` - This is the driver code for this code/script.
+- `k` - User given integer which signifies the upper range of the Catalan series.
+
+## 🧮 Algorithm
+Let's see how it works,
+- Create an array `catalan[]` for storing `ith` Catalan number.
+- Initialize, `catalan[0]` and `catalan[1]` = 1
+- Loop through `i = 2` to the given Catalan number `n`.
+- Loop throught `j = 0` to `j < i` and Keep adding value of `catalan[j] * catalan[i – j – 1]` into `catalan[i]`.
+- Finally, `return catalan[n]`.
+
+## 💻 Input and Output 
+- **Test Case 1 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Nth%20Catalan%20Numbers/Images/catalan-1.png)
+
+- **Test Case 2 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Nth%20Catalan%20Numbers/Images/catalan-2.png)
+
+- **Test Case 3 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Nth%20Catalan%20Numbers/Images/catalan-3.png)
+
+
+## ⏰ Time and Space complexity
+- **Time Complexity:** `O(n^2)`. 
+- **Space Complexity:** `O(n)`.
+
+---------------------------------------------------------------
+## 🖋️ Author
+**Code contributed by, _Abhishek Sharma_, 2022 [@abhisheks008](github.com/abhisheks008)**
+
+[![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

Dynamic Programming/Nth Catalan Numbers/Images/catalan-2.png

@@ -0,0 +1,74 @@
+# Problem Name: Nth Catalan Numbers
+# Approach: Dynamic Programming
+
+# -----------------------------------------------------------------------------------
+
+# Problem Statement: Catalan numbers are defined as a mathematical sequence 
+#                    that consists of positive integers, which can be used to 
+#                    find the number of possibilities of various combinations. 
+#                    Find out the catalan numbers in between the range from 0 to N.
+
+
+# -----------------------------------------------------------------------------------
+
+# Constraints:
+# n -> Integer taken as the range of the Catalan Numbers.
+# catalan[] -> Array of Catalan Numbers from 0 to n.
+
+# -----------------------------------------------------------------------------------
+
+# A dynamic programming based function to find nth
+# Catalan number
+ 
+def catalan(n):
+    if (n == 0 or n == 1):
+        return 1
+ 
+    # Table to store results of subproblems
+    catalan = [0]*(n+1)
+ 
+    # Initialize first two values in table
+    catalan[0] = 1
+    catalan[1] = 1
+ 
+    # Fill entries in catalan[]
+    # using recursive formula
+    for i in range(2, n + 1):
+        for j in range(i):
+            catalan[i] += catalan[j] * catalan[i-j-1]
+ 
+    # Return last entry
+    return catalan[n]
+ 
+ 
+# Driver Code
+print ("-- Nth Catalan Numbers using Dynamic Programming --")
+print ()
+print ("Enter the upper range : ")
+k = int(input())
+print ()
+print ("Printing Nth Catalan Numbers from 0 to {0}...".format(k))
+print ()
+print ("Here you go!")
+for i in range(k):
+	  print(catalan(i), end=" ")
+    
+    
+# -----------------------------------------------------------------------------------
+
+# Output:
+# -- Nth Catalan Numbers using Dynamic Programming --
+
+# Enter the upper range : 
+# 12
+
+# Printing Nth Catalan Numbers from 0 to 12...
+
+# Here you go!
+# 1 1 2 5 14 42 132 429 1430 4862 16796 58786 
+
+# -----------------------------------------------------------------------------------
+
+# Code Contributed by, Abhishek Sharma, 2022
+
+# -----------------------------------------------------------------------------------

Dynamic Programming/Nth Catalan Numbers/Images/catalan-3.png

@@ -0,0 +1,46 @@
+## Overview:
+Two techniques are frequently used for graph traversal: These techniques are called depth-first search (DFS) and breadth-first search (BFS), although we will just talk about BFS. Breadth-first search (BFS) is used to solve many problems, including finding the shortest path in a graph or solving puzzle games such as Rubik’s Cubes.
+
+## What is Breadth First Search in Python?
+Breadth-first search (BFS) is an algorithm for traversing graphs or trees. Breath-first search for trees and graphs are almost the same. BFS uses a queue data structure for finding the shortest path in a graph. We use queue to get the next vertex to start the search, and the visited array is used to mark all the nodes that have been visited, so when it appears again, we will perform BFS on that node.
+
+## Algorithm of DFS in Python
+The algorithm works as follows:
+
+* Create a queue and insert any one vertex of the graph at the back of the queue.
+* Initialize a visited array and mark that vertex as visited.
+* Follow the below process till the queue becomes empty:
+  * Remove a front vertex from the queue.
+  * Get all the adjacent vertices of the removed vertex.
+  * If the adjacent vertex has not been visited, mark it as visited and insert it at the back of the queue.
+
+## Time & Space Complexity
+* Time complexity is `O(V+E)`, where V denotes the number of vertices and E denotes the number of edges. 
+* Space complexity is `O(V)`.
+
+## Applications of Breadth First Search
+* Crawlers in Search Engines
+* Peer-to-Peer Networking
+* GPS Navigation Systems
+* Ford-Fulkerson algorithm
+
+## Input & Output
+### Input:
+
+ <img width=50% src="../Breadth First Search/Images/input.jpg"> 
+
+```python
+graph = {
+    'A': ['B', 'C', 'D'],
+    'B': ['A'],
+    'C': ['A', 'D'],
+    'D': ['A', 'C', 'E'],
+    'E': ['D']
+}
+```
+### Output:
+ <img width=50% src="../Breadth First Search/Images/output.jpg"> 
+ 
+```python
+Breadth-first Search: A B C D E
+```

Dynamic Programming/Nth Catalan Numbers/README.md

@@ -0,0 +1,36 @@
+# Create a graph given in the above diagram.
+graph = {
+    'A': ['B', 'C', 'D'],
+    'B': ['A'],
+    'C': ['A', 'D'],
+    'D': ['A', 'C', 'E'],
+    'E': ['D']
+}
+
+# to print a BFS of a graph
+def bfs(node):
+
+    # mark vertices as False means not visited
+    visited = [False] * (len(graph))
+
+    # make a empty queue for bfs
+    queue = []
+
+    # mark given node as visited and add it to the queue
+    visited.append(node)
+    queue.append(node)
+
+    while queue:
+        # Remove the front vertex or the vertex at 0th index from the queue and print that vertex.
+        v = queue.pop(0)
+        print(v, end=" ")
+
+        for neigh in graph[v]:
+            if neigh not in visited:
+                visited.append(neigh)
+                queue.append(neigh)
+
+
+# Driver Code
+if __name__ == "__main__":
+    bfs('A')