diff --git a/Data-Structures-and-Algos-Topic/Module2-Intermediate-Data-Structures/activities/Act1_LinkedLists/Cards/1.md b/Data-Structures-and-Algos-Topic/Module2-Intermediate-Data-Structures/activities/Act1_LinkedLists/Cards/1.md
new file mode 100644
index 00000000..07777084
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module2-Intermediate-Data-Structures/activities/Act1_LinkedLists/Cards/1.md
@@ -0,0 +1,38 @@
+
+
+
+
+
+
+To put it in the simplest terms, one can think of a linked list like a string of pearls. Each pearl in the string leads to the next. The first pearl on the string can be called the "head" pearl. In a linked list, the "head" node, as can be assumed, is the very first node in the list. Each node contains two things: some data associated with the node, and a reference to the next node in the list.
+
+In a singly linked list, each node (or pearl) has one single reference to the next node (or pearl) in the list. A doubly linked list instead has two references, one for the next node, and one for the previous node. The last node in all linked lists points to a "null" node, signifying the end of the list.
+
+Many benefits come with using a linked list instead of any other similar data structure (like a static array). This includes dynamic memory allocation--if one doesn't know the amount of data they want to store during initialization, a linked list can help with quickly adjusting the size of the list.
+
+However, there are also several disadvantages to using a linked list. More space is used when dynamically allocating memory (mostly for the reference to the next node), and if you want to access an item in the middle, you have to start at the "head" node and follow the references until reaching the item wanted.
+
+**In practice, some insertions cost more. If the list initially allocates enough space for six nodes, inserting a seventh means the list has to double its space (up to 12).**
+
+
+
+### The Linked List
+
+A simple implementation of a linked list includes the following methods:
+
+- Node class: implementing the idea of a Node and its attributes
+- Insert: inserts a new node into the list
+- Size: returns size of list
+- Search: searches list for a node containing the requested data and returns that node if found, otherwise raises an error
+- Delete: searches list for a node containing the requested data and removes it from list if found, otherwise raises an error
+
+Now, we can create the start of our linked list! Luckily, the linked list (as a class) itself is actually the "head" node of the list!
+
+**Note: Upon initialization, a list has no nodes, so the "head" node is set to None. Because a linked list doesn't necessarily need a node to initialized, the "head" node will, by default, set itself to None.**
+
+```python
+class LinkedList(object):
+ def __init__(self, head=None):
+ self.head = head
+```
+Now we can implement the most important attribute of a linked list: the node!
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/1.md
similarity index 95%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/1.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/1.md
index bec77323..35f311f7 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/1.md
@@ -47,4 +47,4 @@ The created graph is an undirected linearly connected graph connecting the integ
You can use `nx.draw(G,with_labels=True)` to show the labels on the nodes. Note that the direction of the graph doesn't matter.
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/10.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/10.md
similarity index 100%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/10.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/10.md
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/11.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/11.md
similarity index 100%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/11.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/11.md
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/2.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/2.md
similarity index 83%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/2.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/2.md
index 84d9efa5..62ae9659 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/2.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/2.md
@@ -8,13 +8,13 @@
Undirected graphs have edges that do not have a direction. The edges indicate a *two-way* relationship, in that each edge can be traversed in both directions. This figure below shows a simple undirected graph. The absence of an arrow tells us that the graph is undirected.
-
+
> The graph can be traversed from node **A** to **B** and vice versa.
-
+
> Undirected Graph
@@ -41,4 +41,4 @@ plt.show() # display the graph
### Output:
- 
\ No newline at end of file
+ 
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/5.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/5.md
similarity index 92%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/5.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/5.md
index 87e3add9..61df2d91 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/5.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/5.md
@@ -10,13 +10,13 @@ Directed graphs have edges with direction. The edges indicate a *one-way* relati
-
+
> The graph can be traversed from vertex **A** to **B**, but not in the opposite direction.
-
+
@@ -78,5 +78,5 @@ plt.show()
### Output:
-
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/6.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/6.md
similarity index 92%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/6.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/6.md
index 9b1110f6..7b871be8 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/6.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/6.md
@@ -24,7 +24,7 @@ Dijkstra's algorithm will assign some initial distance values and improve them s
**unvisited set = {"a", "b", "c", "d"}**
- 
+ 
2. In order to keep track of the total distance from the start node to its destination, we use `distance` to store the current total weight of the smallest path.
@@ -32,7 +32,7 @@ Dijkstra's algorithm will assign some initial distance values and improve them s
Also, set the initial node as current because we will process the initial node first. In this case, we start with node a.
- 
+ 
###### **current_node = a**
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/7.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/7.md
similarity index 91%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/7.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/7.md
index ed6e652f..b4c48b02 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/7.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/7.md
@@ -8,7 +8,7 @@
-
+
@@ -23,7 +23,7 @@
3. For the current node, consider all of its unvisited neighbors and calculate their *tentative* distances through the current node. If the distance is smaller than what the node currently has, we update the distance of the node.
- 
+ 
###### current_node = a
@@ -40,7 +40,7 @@
Now, let's process node `c`:
- 
+ 
###### current_node = a
@@ -69,7 +69,7 @@
5. If the destination node has been marked visited (when planning a route between two specific nodes) or if the smallest tentative distance among the nodes in the *unvisited set* is infinity (when planning a complete traversal, this occurs when there is no connection between the initial node and remaining unvisited nodes), then stop. The algorithm has finished.
6. Otherwise, select the unvisited node marked with the smallest tentative distance and set it as the new "current node." Then, go back to step 3.
-
+
###### current_node = c
@@ -84,7 +84,7 @@ Since `c` has a smaller distance than b, we process c first. We update the dist
Then, we process the node `b`, as the distance of `b` is smaller than the distance of `d`.
-
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/8.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/8.md
new file mode 100644
index 00000000..f4a03bfe
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/8.md
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+### Travel in Europe: A Real-Life Application of Dijkstra's Algorithm
+
+<<<<<<< HEAD:Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/8.md
+Let's say we need to find out the shortest path from point r to point e in Europe, we can use Dijkstra's algorithm.
+Suppose that any geographical map as a graph. Now locations in the map are our **nodes** in algorithm.
+And road between locations are **edges.** **Weights** of the edges are the distance between those two locations here.
+=======
+Let's say we need to find out the shortest path from point r to point e in Europe. We can use Dijkstra's algorithm to do this.
+Suppose that any geographical map has a graph. Locations on the map are our **nodes** in the algorithm. Roads between locations are **edges.** **Weights** of the edges are the distance between locations.
+>>>>>>> 61fbca8d6845aed8b70285df94eadff8f1956bf4:Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/8.md
+
+
+
+
+We’ll start by constructing this graph in Python:
+
+**Step 1:** Create a class called Graph. Use the `__init__()` function to assign values for edges and weights.
+
+```python
+from collections import defaultdict
+
+class Graph():
+ def __init__(self):
+ """
+ self.edges is a dict of all possible next nodes
+ e.g. {'r': ['i', 'a', 'b', 'd'], ...}
+ self.weights has all the weights between two nodes,
+ with the two nodes as a tuple as the key
+ e.g. {('r', 'i'): 7, ('r', 'a'): 2, ...}
+ """
+ self.edges = defaultdict(list)
+ self.weights = {}
+```
+
+**Step 2:** Create a function inside class Graph, which will add directed weighted edges to the graph.
+
+```python
+def add_edge(self, from_node, to_node, weight):
+ # Note: assumes edges are bi-directional
+ self.edges[from_node].append(to_node)
+ self.edges[to_node].append(from_node)
+ self.weights[(from_node, to_node)] = weight
+ self.weights[(to_node, from_node)] = weight
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/9.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/9.md
similarity index 100%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/9.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/Cards/9.md
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/README.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/README.md
index 4cdba671..baeeea86 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/README.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/README.md
@@ -16,4 +16,4 @@ Students will learn about graphs and different ways computer scientists use them
Easy
# Image
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/1.md
new file mode 100644
index 00000000..d88bbbfc
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/1.md
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+## Graphs
+
+A graph is a collection of *nodes* and *edges* that represents relationships:
+
+- **Nodes** are vertices that correspond to objects.
+
+- **Edges** are the connections between objects.
+
+- The graph's edges sometimes have **weights**, which indicate the strength (or some other attribute) of each connection between the nodes.
+
+ Graphs provide us with a very useful data structure. They can help us to find structure within our data. With the advent of machine learning and big data, managing and manipulating our data has never been more important. Learning a little bit of graph theory will help us with that.
+
+ Note that trees are a kind of graph. They are undirected, connected graphs without cycles.
+
+### Python Code:
+
+> In order for this to work, you need to install the modules `networkx` and `matplotlib`.
+>
+> Open terminal and run the statements `pip3 install networkx` and `pip3 install matplotlib`.
+
+NetworkX is a Python library for graphs and networks. Similarly, Matplotlib is a plotting library in Python. With Matplotlib, you can generate plots, bar charts, or histograms with just a few lines of code. We can use Matplotlib to draw graphs.
+
+We can create a Path Graph with linearly connected nodes with the method `path_graph()`. The Python code uses `matplotlib` and `pyplot` to plot the graph. We will give detailed information on `matplotlib` at a later stage in this activity. For now, follow this code to print out nodes and edges, and save your graph to a local image:
+
+```python
+import networkx as nx #set shortcut for networkx
+import matplotlib.pyplot as plt #set shortcut for matplotlib.pyplot
+
+G = nx.path_graph(4) #Return a path graph G of 4 nodes linearly connected by 4-1 edges
+
+print("Nodes of graph: ")
+print(G.nodes()) #return a list of all the nodes in the graph
+print("Edges of graph: ") #nx.draw(G,with_labels=True)
+print(G.edges()) #return a list of all the edges
+nx.draw(G) #Draw the graph G with Matplotlib
+plt.savefig("path_graph1.png") #save the current figure as "path_graph1.png"
+plt.show() # display the graph
+```
+
+The created graph is an undirected linearly connected graph connecting the integer numbers 0 to 3 in their natural order:
+
+You can use `nx.draw(G,with_labels=True)` to show the labels on the nodes. Note that the direction of the graph doesn't matter.
+
+
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/10.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/10.md
new file mode 100644
index 00000000..b833082e
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/10.md
@@ -0,0 +1,55 @@
+
+
+
+
+
+
+**Step 5**: Now, we need to implement our algorithm.
+
+```python
+def dijsktra(graph, initial, end):
+ # shortest paths is a dict of nodes
+ # whose value is a tuple of (previous node, weight)
+ shortest_paths = {initial: (None, 0)}
+ current_node = initial
+ visited = set()
+```
+
+> Here, we initialized the Dijkstra's algorithm function (Step 1 and 2 from the previous slides.) Instead of an unvisited set, we use a visited set this time.
+>
+> For example:
+>
+> current_node = a
+>
+> ###### visited set = {}
+>
+> | | a | b | c | d |
+> | -------- | --------- | --------- | --------- | --------- |
+> | visited? | unvisited | unvisited | unvisited | unvisited |
+> | distance | 0 | ∞ | ∞ | ∞ |
+
+
+
+```python
+ while current_node != end: # do it recursively, until the destination node is reached
+ visited.add(current_node) # set current_node as visited
+ destinations = graph.edges[current_node]
+ weight_to_current_node = shortest_paths[current_node][1]
+
+ for next_node in destinations:
+ weight = graph.weights[(current_node, next_node)] + weight_to_current_node
+ if next_node not in shortest_paths:
+ shortest_paths[next_node] = (current_node, weight)
+ else:
+ current_shortest_weight = shortest_paths[next_node][1]
+ #If the distance is smaller than what the node already has, update the distance of the node.
+ if current_shortest_weight > weight:
+ shortest_paths[next_node] = (current_node, weight)
+```
+
+> Recall Step 3 from the previous card: For the current node, consider all of its unvisited neighbors and calculate their *tentative* distances through the current node. Compare the newly calculated *tentative* distance to the current assigned value and assign the smaller one.
+>
+> Recall Step 6 from the previous card: Select the unvisited node marked with the smallest tentative distance, set it as the new "current node", and go back to step 3.
+>
+> Here, we made a code that calculates the distance between nodes and compares it with its neighbors. We then append the shortest distance path to a list. By doing so, we are repeating the process of both Step 3 and Step 6 from the previous card.
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/11.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/11.md
new file mode 100644
index 00000000..f669b5d7
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/11.md
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+```python
+next_destinations = {node: shortest_paths[node] for node in shortest_paths if node not in visited}
+ if not next_destinations:
+ return "Route Not Possible"
+ # next node is the destination with the lowest weight
+ current_node = min(next_destinations, key=lambda k: next_destinations[k][1])
+```
+
+> Recall Step 4 from the previous card: When we are done considering all unvisited neighbors of the current node, mark it as "visited" and remove it from the *unvisited set*. A visited node will never be checked again.
+>
+> Here the code checks for if the node has been visited or not.
+
+```python
+# Work back through destinations in shortest path
+ path = []
+ while current_node is not None:
+ path.append(current_node)
+ next_node = shortest_paths[current_node][0]
+ current_node = next_node
+ # Reverse path
+ path = path[::-1]
+ return path
+```
+
+> Recall Step 5 from the previous card: If the destination node has been marked visited (when planning a route between two specific nodes) or if the smallest tentative distance among the nodes in the *unvisited set* is infinity (when planning a complete traversal, this occurs when there is no connection between the initial node and remaining unvisited nodes), then stop. The algorithm has finished.
+>
+> Here, we check the node by using a while-loop and see if it is in None or not. If it is not in None, we append it to the list called "path."
+
+**Step 6**
+
+```python
+print(dijsktra(graph, 'r', 'e'))
+```
+
+> We use the comment print to show the graph.
+
+ Output:
+
+``['r', 'a', 'f', 'n', 'e']``
+
+Now, we have confirmation that the shortest path from X to Y is:
+
+**r -> a -> f -> n -> e**
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/12.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/12.md
new file mode 100644
index 00000000..bdc3f579
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/12.md
@@ -0,0 +1,42 @@
+
+
+
+
+
+
+## Keys and Rooms
+### Time to solve a coding problem using a graph!
+
+Keys and Rooms is a delightful puzzle that can be solved with a graph. The problem goes as follows:
+
+There are N rooms and you start in room ```0```.
+Each room has a distinct number in ```0, 1, 2, ..., N-1```, and each room may have some key(s) to access other room(s).
+
+Formally, each **room** ```i``` has a list of keys ```rooms[i]```, and each **key** ```rooms[i][j]``` is an integer in ```[0, 1, ..., N-1]```.
+A key ```rooms[i][j] = v``` opens the room with number ```v```.
+
+Initially, all the rooms start locked (except for room ```0```, which is where you begin).
+
+You can walk back and forth between rooms freely.
+
+**Return ```True``` if and only if you can enter every room. Otherwise, return ```False```.**
+
+
+
+### Examples
+**Example 1:**
+> Input: ```[[1], [2], [3], []]```
+> Output: ```True``` because each of the rooms can be visited.
+
+**Example 2:**
+> Input: ```[[2,3], [1], [0], [2,0]]```
+> Output: ```False``` because there is no way to enter Room 1.
+
+### Starter Code
+Here is some starter code for you:
+```python
+def canVisitRooms(rooms):
+ # should return True/False
+
+```
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/13.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/13.md
new file mode 100644
index 00000000..fc0695d9
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/13.md
@@ -0,0 +1,63 @@
+
+
+
+
+
+
+## Keys and Rooms
+### Explanation
+The key (no pun intented, hehe) to solving this problem is recognizing that the rooms and keys can be represented as a graph, and the goal is to check whether or not every vertex in the graph can be reached (if every room can be entered).
+
+### Breakdown - Three Steps
+Let's break this puzzle into three discrete steps.
+
+**Step 1: Create the Graph**
+The input is a list of lists, and we need to turn this into a graph. I have chosen to use the adjacency map to represent the graph, as it is intuitive to visualize.
+
+```python
+ graph = {i:[] for i in range(len(rooms))}
+ for j in range(len(rooms)):
+ graph[j] = [key for key in rooms[j]]
+```
+> Creating the adjacency map via Python comprehensions ~ so elegant.
+
+**Step 2: Traverse the Graph**
+We must traverse ```graph``` in order to find out whether or not each vertex (room) can be reached. Below is the recursive function ```dfs``` that implements the Depth-First Search algorithm for graph traversal. You will learn more about this in the next Activity.
+
+```python
+def dfs(visited, graph, vertex):
+ if vertex not in visited:
+ visited.add(vertex)
+ for neighbour in graph[vertex]:
+ dfs(visited, graph, neighbour)
+
+ return visited
+```
+> Function to perform depth-first search ~ quite simple indeed.
+
+Note that the function ```dfs``` takes in three parameters:
+* ```visited```, a set which will keep track of which vertices (rooms) we have entered
+* ```graph```, the graph to be traversed
+* ```vertex```, the current vertex being visited
+
+```dfs``` returns ```visited ``` after all reachable vertices have been reached. We will call it from inside ```canVisitRooms``` and assign its value to ```rooms_reached```, shown below.
+
+```python
+rooms_reached = dfs(set(), graph, 0)
+```
+> We pass an empty ```set```, ```graph```, and ```0``` since we start at room ```0```.
+
+**Step 3: Return the Result**
+The final step is to check whether ```rooms_reached``` contains all the rooms we started with—if so, then we were able to unlock each and every room. A simple comparison will do the trick.
+
+```python
+if list(rooms_reached) == list(range(0, len(rooms))):
+ return True
+else:
+ return False
+```
+> Type-casting using ```list()``` is probably the easiest way to do this.
+
+And that's it! Try passing an arbitrary input of the form ```[[keys], [keys],...]``` to test out your code.
+
+Move on to the next card to see all the code in its glory!
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/14.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/14.md
new file mode 100644
index 00000000..9816ecd5
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/14.md
@@ -0,0 +1,37 @@
+
+
+
+
+
+
+## Keys and Rooms
+### Full Solution
+
+```python
+# depth first search recursive
+def dfs(visited, graph, node):
+ if node not in visited:
+ visited.add(node)
+ for neighbour in graph[node]:
+ dfs(visited, graph, neighbour)
+
+ return visited
+
+# essentially check if we can hit every vertex in the graph
+def canVisitRooms(rooms):
+
+ # 1. create adjacency map from rooms
+ graph = {i:[] for i in range(len(rooms))}
+ for j in range(len(rooms)):
+ graph[j] = [key for key in rooms[j]]
+
+ # 2. dfs traverse the adjacency map
+ rooms_reached = dfs(set(), graph, 0)
+
+ # 3. return True or False
+ if list(rooms_reached) == list(range(0, len(rooms))): return True
+ else: return False
+
+# get the result with some input
+result = canVisitRooms( [[1,3],[0],[1],[2]] )
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/2.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/2.md
new file mode 100644
index 00000000..38aabd4e
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/2.md
@@ -0,0 +1,44 @@
+
+
+
+
+
+
+## Undirected Graphs
+
+Undirected graphs have edges that do not have a direction. The edges indicate a *two-way* relationship, in that each edge can be traversed in both directions. This figure below shows a simple undirected graph. The absence of an arrow tells us that the graph is undirected.
+
+
+
+> The graph can be traversed from node **A** to **B** and vice versa.
+
+
+
+
+
+> Undirected Graph
+
+
+
+### Python Code:
+
+```python
+import networkx as nx
+import numpy as np
+import matplotlib.pyplot as plt
+
+G = nx.Graph() #Create an empty graph with no nodes and no edges.
+G.add_edges_from(
+ [('A','B'),('B','C'),('C','D'),('D','E')]) #add edge AB, BC, CD, DE
+
+nx.draw(G) #Draw the graph G with Matplotlib
+plt.show() # display the graph
+```
+
+> add_edge: Add an edge between u and v. The nodes u and v will be automatically added if they are not already in the graph. Edge attributes can be specified with keywords or by providing a dictionary with key/value pairs.
+
+
+
+### Output:
+
+ 
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/3.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/3.md
similarity index 89%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/3.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/3.md
index fe60f27a..cd22ccd4 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/3.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/3.md
@@ -28,7 +28,7 @@ If two vertices have odd degrees and all other vertices have even degrees, then
Example of a **Eulerian Path**:
-
+
The graph has a **Eulerian path**, but no **Eulerian cycle** . Note that the `A ` and `C` have odd degrees.
@@ -36,6 +36,6 @@ The graph has a **Eulerian path**, but no **Eulerian cycle** . Note that the `A
Example of a **Eulerian Cycle**:
-
+
This is an example of a **Eulerian cycle**. All the vertices have an even degree. Follow the path `C` `A` `B` `C` `D` `E` `C`.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/4.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/4.md
similarity index 85%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/4.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/4.md
index f27aec3c..12a24383 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/4.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/4.md
@@ -20,7 +20,7 @@ There are seven bridges in the city. We want to know if it's possible to cross a
In order to solve the problem, the map is turned into a graph. Each piece of land or island is represented as a vertex, and each bridge is represented as an edge connecting the vertices.
-
+
@@ -28,13 +28,13 @@ There is no Hamiltonian path because there are too many vertices with odd edges.
Another example of a graph that doesn't have a **Hamiltonian path**:
-
+
Note that there are two vertices `A` `B` with odd degrees.
Example of a **Hamiltonian Path**:
-
+
This graph has the **Hamiltonian path** `A` `B` `C` `D` `E` `B`, but it doesn't have a **Hamiltonian cycle**.
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/5.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/5.md
new file mode 100644
index 00000000..c5e68f63
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/5.md
@@ -0,0 +1,82 @@
+
+
+
+
+
+
+## Directed Graphs
+
+Directed graphs have edges with direction. The edges indicate a *one-way* relationship, in that each edge can only be traversed in a single direction. This figure below shows a simple directed graph. Edges are usually represented by arrows pointing in the direction the graph can be traversed.
+
+
+
+
+
+
+
+> The graph can be traversed from vertex **A** to **B**, but not in the opposite direction.
+
+
+
+
+
+> Directed Graph
+
+
+
+### Python Code:
+
+```python
+import networkx as nx
+import matplotlib.pyplot as plt
+
+G = nx.DiGraph() #Create an empty directed graph structure with no nodes or edges.
+G.add_edges_from(
+ [('A','B'),('B','C'),('C','D'),('D','E')]) #add edges A to B, B to C, C to D, D to E
+#Because it's a directed graph, the order matters. ('B','A') will create a edge from B to A.
+
+#Set the values to determine the nodes' color.
+val_map = {'A': 1.0,
+ 'D': 0.5714285714285714,
+ 'H': 0.0}
+
+values = [val_map.get(node, 0.25) for node in G.nodes()]
+
+
+```
+
+> Here, we inputted the number of edges and stored their values into val_map (a dictionary). We then used the values in val_map to print out the visualization of the graph by making a values list and used the get()* function.
+
+> *A list is created by placing all the items (elements) inside square brackets separated by commas. It can have any number of items and they may be of different types (integer, float, string, and so on).
+
+> *The get() method is used with a dictionary. It returns the value for the specified key if the key is in the dictionary.
+
+```python
+#Set edge colors and specify the edges you want here
+red_edges = [('A', 'B'), ('B', 'C'),('C','D'),('D','E')]
+edge_colours = ['black' if not edge in red_edges else 'red'
+ for edge in G.edges()]
+black_edges = [edge for edge in G.edges() if edge not in red_edges]
+
+#Need to create a layout when doing
+#Separate calls to draw nodes and edges
+pos = nx.spring_layout(G)
+#draw the nodes of G
+nx.draw_networkx_nodes(G, pos, cmap=plt.get_cmap('jet'),
+ node_color = values, node_size = 500)
+#Draw labels on nodes of G
+nx.draw_networkx_labels(G, pos)
+#Draw the edges
+nx.draw_networkx_edges(G, pos, edgelist=red_edges, edge_color='r', arrows=True)
+nx.draw_networkx_edges(G, pos, edgelist=black_edges, arrows=False)
+plt.show()
+```
+
+> The nx represents the networkx module that we imported in the very beginning. The draw_networkx_nodes, draw_networkx_labels, and draw_networkx_edges are some of the functions of the module. They are used to draw out nodes, node labels, and edges on the graph.
+
+
+
+### Output:
+
+
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/6.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/6.md
new file mode 100644
index 00000000..478ec898
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/6.md
@@ -0,0 +1,45 @@
+
+
+
+
+
+
+## Dijkstra's Algorithm
+
+Dijkstra's algorithm is used to find the shortest path between nodes *a* and *b*. It picks the unvisited vertex with the lowest distance, calculates the distance to each unvisited neighbor, and updates the neighbor's distance if it's smaller. It was conceived by computer scientist Edsger W. Dijkstra in 1956 and published three years later.
+
+Some characteristics of Dijkstra's algorithm:
+
+- Dijkstra's algorithm works on both directed and undirected graphs
+
+- All edges must have non-negative weights
+
+- Graph must be connected
+
+Dijkstra's algorithm will assign some initial distance values and improve them step by step.
+
+##### Initializing the graph:
+
+1. Mark all nodes as unvisited. Create a set of all the unvisited nodes called the *`unvisited set`*.
+
+ **unvisited set = {"a", "b", "c", "d"}**
+
+ 
+
+2. In order to keep track of the total distance from the start node to its destination, we use `distance` to store the current total weight of the smallest path.
+
+ Assign to every node a tentative distance value, set the distance equal to zero for our initial node (since it's 0 away from the initial node) and set the distance to infinity for all other nodes.
+
+ Also, set the initial node as current because we will process the initial node first. In this case, we start with node a.
+
+ 
+
+###### **current_node = a**
+
+###### **unvisited set = {"a", "b", "c", "d"}**
+
+| | a | b | c | d |
+| -------- | --------- | --------- | --------- | --------- |
+| visited? | unvisited | unvisited | unvisited | unvisited |
+| distance | 0 | ∞ | ∞ | ∞ |
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/7.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/7.md
new file mode 100644
index 00000000..62a96e34
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/7.md
@@ -0,0 +1,103 @@
+
+
+
+
+
+
+## Using Dijkstra's Algorithm on the Current Graph
+
+
+
+
+
+
+
+###### current_node = a
+
+| | a | b | c | d |
+| -------- | --------- | --------- | --------- | --------- |
+| visited? | unvisited | unvisited | unvisited | unvisited |
+| distance | 0 | ∞ | ∞ | ∞ |
+
+
+
+3. For the current node, consider all of its unvisited neighbors and calculate their *tentative* distances through the current node. If the distance is smaller than what the node currently has, we update the distance of the node.
+
+ 
+
+ ###### current_node = a
+
+ ###### unvisited set = {"a", "b", "c", "d"}
+
+ | | a | b | c | d |
+ | -------- | --------- | --------- | --------- | --------- |
+ | visited? | unvisited | unvisited | unvisited | unvisited |
+ | distance | 0 | 6 | ∞ | ∞ |
+
+ In this case, `a ` has 2 neighbors: ` b` and ` c`. Both `b` and `c` are unvisited, so we need to calculate their distances. First, let's process `b`. `b` will have a new distance of 6, as b is 6 away from the initial node `a` and 6 is smaller than ∞. Thus, we will update the distance for `b` to 6.
+
+
+
+ Now, let's process node `c`:
+
+ 
+
+###### current_node = a
+
+###### unvisited set = {"a", "b", "c", "d"}
+
+| | a | b | c | d |
+| -------- | --------- | --------- | --------- | --------- |
+| visited? | unvisited | unvisited | unvisited | unvisited |
+| distance | 0 | 6 | 4 | ∞ |
+
+ Going through the same process as node `b`, the distance of `c` will now be updated to 4.
+
+4. When we are done considering all of the unvisited neighbors of the current node, mark the current node as "visited" and remove it from the *`unvisited set`*.
+
+###### current_node = a
+
+###### unvisited set = { "b", "c", "d"}
+
+| | a | b | c | d |
+| -------- | ------- | --------- | --------- | --------- |
+| visited? | visited | unvisited | unvisited | unvisited |
+| distance | 0 | 6 | 4 | ∞ |
+
+
+
+5. If the destination node has been marked visited (when planning a route between two specific nodes) or if the smallest tentative distance among the nodes in the *unvisited set* is infinity (when planning a complete traversal, this occurs when there is no connection between the initial node and remaining unvisited nodes), then stop. The algorithm has finished.
+6. Otherwise, select the unvisited node marked with the smallest tentative distance and set it as the new "current node." Then, go back to step 3.
+
+
+
+###### current_node = c
+
+###### unvisited set = { "b", "d"}
+
+| | a | b | c | d |
+| -------- | ------- | --------- | ------- | --------- |
+| visited? | visited | unvisited | visited | unvisited |
+| distance | 0 | 6 | 4 | 10 |
+
+Since `c` has a smaller distance than b, we process c first. We update the distance of `d` to 10, as 4 + 6 = 10. We mark c as "visited" and delete it from the *`unvisited set`*.
+
+Then, we process the node `b`, as the distance of `b` is smaller than the distance of `d`.
+
+
+
+
+
+###### current_node = b
+
+###### unvisited set = {"d"}
+
+| | a | b | c | d |
+| -------- | ------- | ------- | ------- | --------- |
+| visited? | visited | visited | visited | unvisited |
+| distance | 0 | 6 | 4 | 8 |
+
+`b` has a unvisited neighbor `d` . Going through `b`, the path from `a` to ` d` is 6 + 2 = 8, which is smaller than 10 ( `d`'s current distance). Thus, we update the distance of `d` to 8. Set `b` as "visited" and delete it from the *`unvisited set`*.
+
+According to step 5, since we only have a unvisited node left and it's already updated to the smallest path, we're done!
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/8.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/8.md
similarity index 79%
rename from Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/8.md
rename to Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/8.md
index 13e64985..332bba72 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/8.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/8.md
@@ -6,11 +6,12 @@
### Travel in Europe: A Real-Life Application of Dijkstra's Algorithm
-Let's say we need to find out the shortest path from point r to point e in Europe. We can use Dijkstra's algorithm to do this.
-Suppose that any geographical map has a graph. Locations on the map are our **nodes** in the algorithm. Roads between locations are **edges.** **Weights** of the edges are the distance between locations.
+Let's say we need to find out the shortest path from point r to point e in Europe, we can use Dijkstra's algorithm.
+Suppose that any geographical map as a graph. Now locations in the map are our **nodes** in algorithm.
+Roads between locations are **edges.** **Weights** of the edges are the distance between those two locations here.
-
+
We’ll start by constructing this graph in Python:
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/9.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/9.md
new file mode 100644
index 00000000..4c83d16c
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/cards/9.md
@@ -0,0 +1,42 @@
+
+
+
+
+
+
+**Step 3**: Assign the class Graph to a variable graph so that we can use the function in the class.
+
+```python
+graph = Graph()
+```
+
+
+
+**Step 4**: Implement the Europe travel graph with all directed weighted edges.
+
+```edges = [
+edges = [('r', 'i', 7),
+ ('r', 'a', 2),
+ ('r', 'b', 3),
+ ('r', 'g', 4),
+ ('i', 'a', 3),
+ ('i', 'm', 4),
+ ('a', 'm', 4),
+ ('a', 'f', 5),
+ ('b', 'd', 2),
+ ('m', 'c', 1),
+ ('c', 'f', 3),
+ ('n', 'f', 2),
+ ('n', 'e', 2),
+ ('k', 'l', 6),
+ ('k', 'j', 4),
+ ('k', 'd', 4),
+ ('l', 'd', 1),
+ ('j', 'e', 5),
+]
+
+for edge in edges:
+ graph.add_edge(*edge)
+```
+
+Now, we should have a Europe travel graph just like the one from before.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/13-checkpoint.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/13-checkpoint.md
new file mode 100644
index 00000000..c6c89eb1
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/13-checkpoint.md
@@ -0,0 +1,3 @@
+**Name:** Adjacency Map
+**Instruction:** What's it called when you represent a graph via a map?
+**Type:** Short Answer
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/4-checkpoint.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/4-checkpoint.md
new file mode 100644
index 00000000..c3e639c6
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/checkpoints/4-checkpoint.md
@@ -0,0 +1,3 @@
+**Name:** Eulerian and Hamiltonian Paths
+**Instruction:** What's the difference between an Eulerian Path and a Hamiltonian Path?
+**Type:** Short Answer
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/1.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/1.jpg
new file mode 100644
index 00000000..c53e2edd
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/1.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2a.jpg
new file mode 100644
index 00000000..84f47dbc
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2b.jpg
new file mode 100644
index 00000000..6e56021d
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2c.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2c.jpg
new file mode 100644
index 00000000..5c988c5a
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/2c.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3a.jpg
new file mode 100644
index 00000000..1ce3cd2d
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3b.jpg
new file mode 100644
index 00000000..eeee22b9
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/3b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4a.jpg
new file mode 100644
index 00000000..ca2530ba
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4b.jpg
new file mode 100644
index 00000000..7bc1158b
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4c.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4c.jpg
new file mode 100644
index 00000000..7bc1158b
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4c.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4d.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4d.jpg
new file mode 100644
index 00000000..4ecf851b
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/4d.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5a.jpg
new file mode 100644
index 00000000..0ec6eb43
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5b.jpg
new file mode 100644
index 00000000..0c0d618b
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5c.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5c.jpg
new file mode 100644
index 00000000..04844a20
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/5c.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6a.jpg
new file mode 100644
index 00000000..8caf1efd
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6b.jpg
new file mode 100644
index 00000000..239846a0
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/6b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7a.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7a.jpg
new file mode 100644
index 00000000..d125ebeb
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7a.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7b.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7b.jpg
new file mode 100644
index 00000000..7281d534
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7c.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7c.jpg
new file mode 100644
index 00000000..0214839c
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7c.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7d.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7d.jpg
new file mode 100644
index 00000000..c9d6dd6c
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7d.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7e.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7e.jpg
new file mode 100644
index 00000000..954a2069
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/7e.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/8.jpg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/8.jpg
new file mode 100644
index 00000000..546e4a1e
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/8.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/lockedroom.jpeg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/lockedroom.jpeg
new file mode 100644
index 00000000..4856ecf3
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/lockedroom.jpeg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/readme.jpeg b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/readme.jpeg
new file mode 100644
index 00000000..c708333e
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Activity1_Graphs/images/readme.jpeg differ
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1-1.md
index ef2a80db..1548a93c 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1-1.md
@@ -4,7 +4,15 @@
-### Step 1: DFS and Backtracking Search
+# steps
-In the algorithm, we can use **DFS** to inspect all nodes in our graph and assign a color to each one. In order to quicken the process, we can use **Backtracking Search**. Backtracking search will keep track of which colors are valid for a specific vertex. It will also ensure that the color assigned to the vertex currently being inspected has not been assigned to a connecting vertex. If no possible color can be assigned to a vertex, the backtracking search will indicate as such and the program will acknowledge that the graph is not n-Colorable.
+## 1-1-1 Step 1
+### name
+```
+DFS and Backtracking Search
+```
+### md_content
+```
+In the algorithm, we can use **DFS** to inspect all nodes in our graph and assign a color to each one. In order to quicken the process, we can use **Backtracking Search**. Backtracking search will keep track of which colors are valid for a specific vertex. It will also ensure that the color assigned to the vertex currently being inspected has not been assigned to a connecting vertex. If no possible color can be assigned to a vertex, the backtracking search will indicate as such and the program will acknowledge that the graph is not n-Colorable.
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1.md
index a25268c7..bb475416 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1-1.md
@@ -5,19 +5,33 @@
This lab will require you to use **Depth First Search** and **Backtracking Search** to solve the n-Colorable problem. Therefore, we will briefly review both of these concepts.
+# steps
-#### Step 1: Depth First Search (DFS)
+## 1-1 Step 1
+### name
+```
+Depth First Search (DFS)
+```
+### md_content
+```
In **DFS** or **depth first search**, we start at a root node in our graph (this can be *the* root node, but also the root of any subtree), and traverse down a single branch to find our target node. If we don't find it, we traverse down the other branch. If we still don't find it, we pick one of the root's children to be the new root node and restart the process. We can perform our search in different orders just as with traversal, namely **preorder**, **inorder**, or **postorder**.
How do you think we can use **DFS** in our solution to the n-Colorable problem?
+```
+### image
+
-
+## 1-1 Step 2
-#### Step2: Backtracking Search
-
+### name
+```
+Backtracking Search
+```
+### md_content
+```
With **backtracking search**, we solve the problem recursively, but when a solution does not satisfy the conditions of our problem, we remove it from consideration at that point in time. In other words, we try every single possible attempt at solution, and discard all the failures until we arrive at an answer that works.
Backtracking is an algorithmic technique for solving problems recursively by trying to build a solution incrementally, one piece at a time, removing those solutions that fail to satisfy the constraints of the problem at any point of time.
@@ -25,9 +39,11 @@ Backtracking is an algorithmic technique for solving problems recursively by try
How do you think we can apply this logic of **backtracking search** into our solution to the n-Colorable problem to quicken our process of assigning colors to vertices?
-
-
-
-
-
-In this example, we first try left tree A. For node A, we have two options, C and D. Both of them are bad. As root A does not satisfy the solution, we discard this solution. Root B is the counterpart of root A, so we then try node B. We also have two choices, node E and node F. Node E is good, thus we find one solution, while node F is bad, so we discard that solution.
\ No newline at end of file
+```
+### image
+
+
+### md_content
+```
+In this example, we first try left tree A. For node A, we have two options, C and D. Both of them are bad. As root A does not satisfy the solution, we discard this solution. Root B is the counterpart of root A, so we then try node B. We also have two choices, node E and node F. Node E is good, thus we find one solution, while node F is bad, so we discard that solution.
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1.md
index 016b4176..ccb4c584 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/1.md
@@ -6,7 +6,7 @@
The n-Colorable problem is a famous problem in graph theory. The goal is to color the vertices of an undirected graph such that no two vertices with the same color are connected by an edge. The catch is that you only have `n` colors. Obviously, we would assume that `n` is smaller than the number of nodes in the graph, otherwise it wouldn't be a problem. If a graph can be colored in this way using only `n` colors, we say that it is n-Colorable. The variable `n` is chosen by the user.
-
+
The goal of this lab is to create a program that implements the n-Colorable problem. The user provides a CSV file that contains an adjacency matrix representing the graph. The program must convert this CSV file into a 2D list representation of the adjacency matrix. The program will ask the user for the **number of vertices** in the graph and **n**.
@@ -24,7 +24,7 @@ The program will assign **colors 1:n** to each vertex in the graph. The element
An adjacency matrix has a 1 at index `i` and `j` if there is an edge between vertex `i` and vertex `j` on the graph.
-
+
Assuming that the graph above is undirected, the CSV file should contain:
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/11.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/11.md
deleted file mode 100644
index 22a5b36a..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/11.md
+++ /dev/null
@@ -1,33 +0,0 @@
-
-
-
-
-
-
-This lab will require you to use **Depth First Search** and **Backtracking Search** to solve the n-Colorable problem. Therefore, we will briefly review both of these concepts.
-
-#### Step 1: Depth First Search (DFS)
-
-In **DFS** or **depth first search**, we start at a root node in our graph (this can be *the* root node, but also the root of any subtree), and traverse down a single branch to find our target node. If we don't find it, we traverse down the other branch. If we still don't find it, we pick one of the root's children to be the new root node and start over. We can perform our search in different orders just as with traversal, namely **preorder**, **inorder**, or **postorder**.
-
-How do you think we can use **DFS** in our solution to the n-Colorable problem?
-
-
-
-
-
-#### Step2: Backtracking Search
-
-With **backtracking search**, we solve the problem recursively. However, when a solution does not satisfy the conditions of our problem, we remove it from consideration. In other words, we try every possible attempt at finding a solution and discard all failures until we arrive at a viable answer.
-
-Backtracking is an algorithmic-technique for solving problems recursively by attempting to build a solution incrementally, removing failures to satisfy the constraints of the problem at any point in time.
-
-
-
-How do you think we can apply this logic of **backtracking search** into our n-Colorable solution to quicken the assignment of colors to vertices?
-
-
-
-
-
-In this example, we first try left tree A. For node A, we have two options, C and D. Both of them are bad; root A does not satisfy the solution, so we discard this solution. Root B is the counterpart of root A, so we then try node B. We also have two choices, node E and node F. Node E is good, so we find one solution, while node F is bad, which we will discard.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/111.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/111.md
deleted file mode 100644
index 322f3708..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/111.md
+++ /dev/null
@@ -1,26 +0,0 @@
-
-
-
-
-
-
-In the algorithm, we can use **DFS** to inspect all nodes in our graph and assign a color to each. In order to speed up the process, we can use **Backtracking Search**. Backtracking search will track which colors are valid for a specific vertex. A color is valid if no connecting nodes already have it assigned. If no viable color can be assigned to a vertex (no valid color exists for this node), the program will determine that the graph is not n-Colorable.
-
-
-
-
-
-
-
-Let's see this in action with the graph we saw earlier:
-
-
-
-In this case, `n` = 2 and red and blue are our chosen colors. Let's walk through step by step to see how this assignment was reached. Assume we used a preorder search pattern. We first assigned a color to `1`. Let's assume that we attempted to assign blue first, then red second. Since this was the first node, we had no problem assigning blue to it. We then moved on to `2`.
-
-Here is where backtracking search came in. First, we checked to see if we could assign blue as its color. We couldn't because `2` is connected to `1`, which is blue, so we had to assign `2` to be red. Then, we moved on to `4`.
-
-We attempted to assign blue to `4`. No problem! It is not connected to any blue nodes, so we could assign its color to be blue. At this point, we have finished traversing `1`'s left tree, so we moved to its right tree. We then looked at `3`.
-
-Could we have assigned blue to `3`? No, for the same reason as `2`. Since `3` is connected to `1`, which was assigned the color blue, we have to assign the color red. You'd think we would move on to `4`, but wait! We already assigned this node its color. At this point, DFS has completed traversing the graph, which means we have solved the problem and shown that this graph is n-Colorable!
-
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1-1.md
index 64aa1e7f..56324a32 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1-1.md
@@ -4,12 +4,25 @@
-**Step 1: We must read each row in the CSV file in a for-loop and separate the integer values from the commas. **
+# steps
-**Step 2: Place each row of the CSV file into our adjacency graph. **
+## 2-1-1 Step 1
-Here's the code to do so.
+### name
+```
+We must read each row in the CSV file in a for loop and separate the integer values from the commas.
+```
+## 2-1-1 Step 2
+### name
+```
+Place each row of the CSV file into our adjacency graph.
+```
+### md_content
+```
+Here's the code to do so.
+```
+### code_snippet
```Python
#Open file as a csvfile
with open(filename) as csvfile:
@@ -25,9 +38,12 @@ with open(filename) as csvfile:
graph.append(rowNums) #put new row below previous graph to make it as an matrix
```
-
+### md_content
+```
Don't forget to import the CSV package at the top of your file.
+```
+### code_snippet
```Python
import csv
```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1.md
index 33d030b5..96d4418d 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/2-1.md
@@ -4,17 +4,28 @@
-### Step 1: Initialize a List
+# steps
+## 2-1 Step 1
+
+### name
+```
+Initialize a List
+```
+### md_content
+```
You must initialize a list for the graph that will become our 2D list adjacency matrix. For now, you can simply put:
+```
+### code_snippet
```Python
graph = []
```
-
+### md_content
+```
Then, use the content of the CSV file to fill out the 2D list. Append each row into the graph list you just initialized. Remember that the values are separated by commas. You must read in the values, not the commas.
**Hint:** You can use Python's `split()` function to remove certain characters from a string.
To illustrate what this means in our previous example, you would need to convert the sample CSV file into the table that we saw. This table will be assigned to `graph`.
-
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/21.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/21.md
deleted file mode 100644
index 93296cb1..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/21.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-
-
-
-
-
-### Step 1: Initialize a List
-
-You must initialize a list for the graph that will become our 2D list adjacency matrix. For now, you can simply put:
-
-```Python
-graph = []
-```
-
-Then, use the content of the CSV file to fill out the 2D list. Append each row into the graph list you just initialized. Remember that the values are separated by commas; you must read in the *values*, not the commas.
-
-**Hint:** You can use Python's `split()` function to remove certain characters from a string.
-
-To illustrate what this means with our previous example, you would need to convert the sample CSV file into the table that we saw. This table will be assigned to `graph`.
-
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/211.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/211.md
deleted file mode 100644
index 178d7133..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/211.md
+++ /dev/null
@@ -1,33 +0,0 @@
-
-
-
-
-
-
-**Step 1: We must read each row in the CSV file in a for-loop and separate the integer values from the commas. **
-
-**Step 2 : Place each row of the CSV file into our adjacency graph. **
-
-Here's the code to do so:
-
-```Python
-#Open file as a csvfile
-with open(filename) as csvfile:
- csv_reader = csv.reader(csvfile, delimiter=",")
-
- # Parse through csvfile by line (which are the rows of the adjacency matrix in our case)
- for row in csvfile:
- # Make a list of ints from the current row in the csv file by splitting the numbers from the ,
- rowNums = [int(x) for x in row.split(',') if x.strip().isdigit()]
- #x.strip().isdigit() return true if all the characters in the string is digit
- #split them by ','
- # Place the list of ints we just made into our 2D list graph
- graph.append(rowNums) #put new row below previous graph to make it as an matrix
-
-```
-
-Don't forget to import the CSV package at the top of your file.
-
-```Python
-import csv
-```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1-1.md
index f2a05517..d3b1f005 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1-1.md
@@ -3,19 +3,31 @@
+# steps
-### Step 1: `initColors()`
+## 3-1-1 Step 1
+### name
+```
+`initColors()`
+```
+### md_content
+```
`initColors()` simply initializes a list of colors that holds numVertices 0s and returns the list. Here is the code that allows us to do that:
-
+```
+### code_snippet
```Python
def initColors(numVertices):
colors = [0] * numVertices
return colors
```
-
+### md_content
+```
This would create the following list:
-
-
-
-We would have received `numVertices` from either the length or width of our `graph` list from earlier.
\ No newline at end of file
+```
+### image
+
+### md_content
+```
+We would have received `numVertices` from either the length or width of our `graph` list from earlier.
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1.md
index 7822ce6f..51289835 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3-1.md
@@ -4,7 +4,16 @@
-### Step 1: Initialize a Colors List
+# steps
+## 3-1 Step 1
+
+### name
+```
+Initialize a Colors List
+```
+### md_content
+```
Since we will have color assignments to all vertices, we must initialize a colors list that is numVertices long. It is okay to initialize the list to all 0s because we will be changing them later on in the program.
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3.md
index 62287ef3..a218f712 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/3.md
@@ -12,5 +12,5 @@ Now that we have our 2D list adjacency matrix from the CSV file, we need to crea
This list will look similar to the one we saw in a previous example:
-
+
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/31.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/31.md
deleted file mode 100644
index 70aa1d41..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/31.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
-
-
-Since we will have colors assigned to all vertices, we must initialize a colors list that is numVertices long. It is okay to initialize the list to all 0s because we will be changing them later on in the program. In other words, using our sample list:
-
-
-
-
-
-To create this list, we first need to determine its length. In this case, the length is `4`, the number of nodes in our example graph. We would then need to initialize all values in the created list to `0` before populating them later with the values shown above.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/311.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/311.md
deleted file mode 100644
index 617dddf0..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/311.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-
-
-
-
-### Step 1: `initColors()`
-
-`initColors()` simply initializes a list of colors that holds numVertices 0s and returns the list. Here is the code that allows us to do that:
-
-```Python
-def initColors(numVertices):
- colors = [0] * numVertices
- return colors
-```
-
-This creates the following list:
-
-
-
-We would have received `numVertices` from either the length or width of our `graph` list from earlier.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1-1.md
index 39a0e047..356a3d65 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1-1.md
@@ -5,11 +5,20 @@
You'll be giving the `checkVertex()` function the adjacency matrix graph, the current index of the node you're inspecting, the colors vector, the color you want to assign to the current index, and the number of vertices.
+# steps
-**Step 1: Check if the connected vertex has the color that we want to give to the current vertex**
+## 4-1-1 Step 1
+### name
+```
+check if the connected vertex has the color that we want to give to the current vertex
+```
+### md_content
+```
We will look at all the entries in the current index's row in the adjacency matrix and look for a 1. If we see a 1, that means that the current index's vertex is connected to another, so we check if that connected vertex has the color assignment we want for the current vertex. If we get through the entire current index's row without satisfying both conditions, it's safe to assign the color to the current vertex and we return True. The code is much more concise than the explanation. Let's check it out:
+```
+### code_snippet
```Python
def checkVertex(graph, curIndex, colors, color, numVertices):
for i in range(0,numVertices):
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1.md
index da1e1116..2468b709 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-1.md
@@ -4,7 +4,16 @@
-### Step 1: Check if we can assign the color to the vertex
+# steps
+## 4-1 Step 1
+
+### name
+```
+check if we can assign the color to the vertex
+```
+### md_content
+```
Before we get into functions that will assign the colors, it is a good idea to build a function that checks whether or not a certain vertex can be assigned a specified color. To do so, it must check whether any connecting vertices already have that color assignment. Try building a `checkVertex()` function. This function will allow us to implement backtracking search in `graphColoring()`.
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2-1.md
index aaf29a09..2b5e813e 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2-1.md
@@ -4,10 +4,19 @@
-### Step 1: `graphColoring()`
+# steps
-Here is the Python implementation of the `graphColoring()` function:
+## 4-2-1 Step 1
+### name
+```
+`graphColoring()`
+```
+### md_content
+```
+Here is the Python implementation of the `graphColoring()` function:
+```
+### code_snippet
```Python
def graphColoring(graph, n, colors, curIndex, numVertices):
#Base Case: return True once at last row of graph
@@ -29,5 +38,7 @@ def graphColoring(graph, n, colors, curIndex, numVertices):
```
-
-Note the recursive usage of **DFS** and **backtracking search** being implemented by returning `False` if no color can be assigned to a vertex.
\ No newline at end of file
+### md_content
+```
+Note the recursive usage of **DFS** and **backtracking search** being implemented by returning `False` if no color can be assigned to a vertex.
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2.md
index 1dacfb0c..1319f7ac 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/4-2.md
@@ -4,16 +4,31 @@
-**Step 1: DFS**
+# steps
-In this function, you will be using **DFS** to inspect all of the graph's vertices.
-
-**Step 2: Backtracking Search**
+## 4-2 Step 1
+### name
+```
+DFS
+```
+### md_content
+```
+In this function, you will be using **DFS** to inspect all of the graph's vertices.
+```
+## 4-2 Step 2
+
+### name
+```
+Backtracking Search
+```
+### md_content
+```
You will be using **Backtracking Search** to tell if a certain vertex does not have a valid color. If that is the case, the function will return `False` to main.
Since we want to use **Backtracking Search** in our algorithm, our `graphColoring()` function could take advantage of the previous one `checkVertex()` to check if the vertex currently being inspected has a valid color. If there isn't a valid color, `graphColoring()` should acknowledge this and return `False` so that `main()` knows that the graph is not n-Colorable.
Also, don't forget to do your color assigning to vertices in the colors list.
-Note that you may find recursion helpful for this part (DFS).
\ No newline at end of file
+Note that you may find recursion helpful for this part (DFS).
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/41.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/41.md
deleted file mode 100644
index df8266b2..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/41.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-
-
-
-
-### Step 1: Check if we can assign the color to the vertex
-
-Before we get into the functions that will assign the colors, it is a good idea to build a function that, when given a certain vertex and color, it checks if that vertex can be assigned that color. To do so, the function must check whether any connecting vertices already have that color assignment. Try building a `checkVertex()` function. This function will allow us to implement backtracking search in `graphColoring()`.
-
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/411.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/411.md
deleted file mode 100644
index 4920248b..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/411.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-
-
-
-
-You'll be giving the `checkVertex()` function the adjacency matrix graph, current index of the node being inspected, the colors vector, the color to assign the current index, and the number of vertices. We will look at all entries in the current index's row in the adjacency matrix and look for a 1. If we see a 1, that means that the current index's vertex is connected to another vertex, so we check if that connected vertex has the color assignment that we want to give to the current vertex. If we get through the entire current index's row without satisfying both conditions, we can assign the color to the current vertex and we return True. The code is much more concise than the explanation. Let's check it out:
-
-```Python
-def checkVertex(graph, curIndex, colors, color, numVertices):
- for i in range(0,numVertices):
- if graph[curIndex][i] == 1 and colors[i] == color:
- return False
-
- return True
-```
-
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/42.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/42.md
deleted file mode 100644
index a2c3608b..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/42.md
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-
-
-
-
-**Step 1: DFS**
-
-In this function, you will be using **DFS** to inspect all of the graph's vertices.
-
-**Step 2: Backtracking Search**
-
-You will be using **Backtracking Search** to tell if a certain vertex doesn't have a valid color. If that is the case, the function will return `False` to main.
-
-Since we want to use **Backtracking Search** in our algorithm, our `graphColoring()` function could take advantage of the previous one `checkVertex()` to check if there is a valid color for the vertex currently being inspected. If there is not a valid color, `graphColoring()` should acknowledge this and return `False` so that `main()` knows that the graph is not n-Colorable.
-
-Also, don't forget to assign colors to vertices in the colors list.
-
-Note that you may find recursion helpful for this part (DFS).
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/421.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/421.md
deleted file mode 100644
index aaf29a09..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/421.md
+++ /dev/null
@@ -1,33 +0,0 @@
-
-
-
-
-
-
-### Step 1: `graphColoring()`
-
-Here is the Python implementation of the `graphColoring()` function:
-
-```Python
-def graphColoring(graph, n, colors, curIndex, numVertices):
- #Base Case: return True once at last row of graph
- if curIndex == numVertices:
- return True
-
- # for loop that goes from 1 to n. Which is one loop per color in colors
- for i in range(1, n+1):
- #Call checkVertex on the currentColor to see if the current vertex can have that color
- if checkVertex(graph, curIndex, colors, i, numVertices) == True:
- # If previous condition holds, assign color i to the current vertex
- colors[curIndex] = i
- # Now that we've assigned the color i to current vertex, recursively call graphColoring() on the next vertex
- if graphColoring(graph, n, colors, curIndex + 1, numVertices) == True:
- return True
- colors[curIndex] = 0
- #Returns false if no color can be assigned to a specific vertex. This is part of backtracking search
- return False
-```
-
-
-
-Note the recursive usage of **DFS** and **backtracking search** being implemented by returning `False` if no color can be assigned to a vertex.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1-1.md
index 081ff059..cca9156c 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1-1.md
@@ -3,11 +3,19 @@
+# steps
-### Step 1：`main()`
+## 5-1-1 Step 1
+### name
+```
+`main()`
+```
+### md_content
+```
The `main()` function is responsible for calling all appropriate functions and getting user input. Here is a proper implementation of the `main()` function:
-
+```
+### code_snippet
```Python
def main():
# Call fileReader() function to get 2D list graph
@@ -30,5 +38,7 @@ def main():
for color in colors:
print(color)
```
-
-Note that your `main()` function may not look exactly like this, and that is okay. Just make sure your code has all the desired functionality for the program to work correctly. Also note that in this case, the file with the adjacency matrix provided by the user is called `test.csv`.
\ No newline at end of file
+### md_content
+```
+Note that your `main()` function may not look exactly like this, and that is okay. Just make sure your code has all the desired functionality for the program to work correctly. Also note that in this case, the file with the adjacency matrix provided by the user is called `test.csv`.
+```
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1.md
index 232ba26d..996ade9b 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/5-1.md
@@ -3,8 +3,15 @@
+# steps
-### Step 1: `main()`
+## 5-1 Step 1
+### name
+```
+`main()`
+```
+### md_content
+```
Since the `main()` function drives your program's functionality, it must ask the user for the previously mentioned input, call `initColors()` to get the colors, and print existing color assignments once `graphColoring()` finishes running. Make sure you don't forget to include some of the `main()` functionality.
-
+```
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/51.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/51.md
deleted file mode 100644
index efd0cbad..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/51.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-
-
-
-
-### Step 1: `main()`
-
-Since the `main()` function drives the functionality of your program, it must ask the user for the previously mentioned input, call `initColors()` to get the colors, and print any existing color assignments once `graphColoring()` finishes running. Make sure you don't forget to include some of the `main()` functionality.
-
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/511.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/511.md
deleted file mode 100644
index fc1612da..00000000
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/Cards/511.md
+++ /dev/null
@@ -1,34 +0,0 @@
-
-
-
-
-
-
-### Step 1：`main()`
-
-The `main()` function is responsible for calling all appropriate functions and getting user input. Here is a proper implementation of the `main()` function:
-
-```Python
-def main():
- # Call fileReader() function to get 2D list graph
- graph = fileReader("test.csv")
-
- # Get numVertices by getting length of graph
- numVertices = len(graph)
-
- # Get user input for n
- n = int(input("Enter n: "))
-
- # Call initColors() to initialize colors list
- colors = initColors(numVertices)
-
- #Call the graphColoring() function and if it returns false, that means that the graph can't be colored
- if graphColoring(graph, n colors, 0, numVertices) == False:
- print("Graph cannot be colored")
- else:
- print("The color assignments are: ")
- for color in colors:
- print(color)
-```
-
-Note that your `main()` function may not look exactly like this; that is okay. Just make sure your code has all the desired functionality for the program to work correctly. Also note that the file with the adjacency matrix provided by the user is called `test.csv`.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/README.md b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/README.md
index dc596aa8..4b423d63 100644
--- a/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/README.md
+++ b/Data-Structures-and-Algos-Topic/Module3-Search-and-Sorting-Algos/Lab5_nColorable/README.md
@@ -16,4 +16,4 @@ Students will solve the n-Colorable problem using Depth First Search and Backtra
Medium/Hard
# Image
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/2.md b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/2.md
new file mode 100644
index 00000000..9070f580
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/2.md
@@ -0,0 +1,21 @@
+
+
+
+
+
+
+The first task to designing our program is to create a function `fileReader()` that reads the user-provided CSV file which contains the adjacency matrix. The function should place the content into a 2D list structure. The CSV file should look very similar in format to the table below:
+
+
+
+#### Sample CSV File:
+
+0,1,0,1
+
+1,0,1,0
+
+0,1,0,1
+
+1,0,1,0
+
+As you can see, our sample CSV provides the exact same information as present in our table. Each node has its own line, and the relationship between nodes (whether they are connected or not) are separated by commas.
\ No newline at end of file
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/4.md b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/4.md
new file mode 100644
index 00000000..4e575b11
--- /dev/null
+++ b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/Cards/4.md
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+Since we have created our adjacency matrix and a colors list, the next step is to create the function that does the coloring of the vertices, the `graphColoring()` function. You may want to call other functions within `graphColoring()` to make your code more readable. You can use **DFS** to inspect the vertices of the graph and **Backtracking Search** to make the process quicker in some cases.
+
+
+
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1.png b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1.png
new file mode 100644
index 00000000..32b38e4d
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1.png differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11.gif b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11.gif
new file mode 100644
index 00000000..32dd3949
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11.gif differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11b.jpg b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11b.jpg
new file mode 100644
index 00000000..e8211926
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/11b.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1b.png b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1b.png
new file mode 100644
index 00000000..78036ca4
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/1b.png differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/2.jpg b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/2.jpg
new file mode 100644
index 00000000..22be1881
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/2.jpg differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/3.png b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/3.png
new file mode 100644
index 00000000..708eeb44
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/3.png differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/311.png b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/311.png
new file mode 100644
index 00000000..febcc9d3
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/311.png differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/4.png b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/4.png
new file mode 100644
index 00000000..6e4a415d
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/4.png differ
diff --git a/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/readme.jpeg b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/readme.jpeg
new file mode 100644
index 00000000..7b13e467
Binary files /dev/null and b/Data-Structures-and-Algos-Topic/labs/Lab5_nColorable/images/readme.jpeg differ