Update app.py

app.py

@@ -23,7 +23,108 @@ sidebar_option = st.sidebar.radio("Select an option",
                                   "Drawing: Simple Path", "Drawing: Spectral Embedding", "Drawing: Traveling Salesman Problem",
                                   "Drawing: Weighted Graph", "3D Drawing: Animations of 3D Rotation", "3D Drawing: Basic Matplotlib",
                                   "Graph: DAG - Topological Layout", "Graph: Erdos Renyi", "Graph: Karate Club", "Graph: Minimum Spanning Tree",
-                                  "Graph: Triads", "Algorithms: Cycle Detection", "Algorithms: Greedy Coloring"])
+                                  "Graph: Triads", "Algorithms: Cycle Detection", "Algorithms: Greedy Coloring", "Algorithms: Find Shortest Path"])
+
+def plot_shortest_path(graph, start_node, end_node):
+    # Find the shortest path from start_node to end_node
+    path = nx.shortest_path(graph, start_node, end_node, weight="weight")
+    st.write("Shortest Path:", path)
+
+    # Create a list of edges in the shortest path
+    path_edges = list(zip(path, path[1:]))
+
+    # Create a list of all edges, and assign colors based on whether they are in the shortest path or not
+    edge_colors = [
+        "red" if edge in path_edges or tuple(reversed(edge)) in path_edges else "black"
+        for edge in graph.edges()
+    ]
+
+    # Visualize the graph
+    pos = nx.spring_layout(graph)
+    nx.draw_networkx_nodes(graph, pos)
+    nx.draw_networkx_edges(graph, pos, edge_color=edge_colors)
+    nx.draw_networkx_labels(graph, pos)
+    nx.draw_networkx_edge_labels(
+        graph, pos, edge_labels={(u, v): d["weight"] for u, v, d in graph.edges(data=True)}
+    )
+
+    plt.title(f"Shortest Path from {start_node} to {end_node}")
+    st.pyplot(plt)
+
+def algorithms_shortest_path():
+    st.title("Algorithms: Find Shortest Path")
+
+    # Option to choose between creating your own or using the default example
+    graph_mode = st.radio(
+        "Choose a Mode:",
+        ("Default Example", "Create Your Own"),
+        help="The default example shows a predefined graph, or you can create your own."
+    )
+
+    if graph_mode == "Default Example":
+        # Create a predefined graph with nodes and weighted edges
+        G = nx.Graph()
+        G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
+        G.add_edge("A", "B", weight=4)
+        G.add_edge("A", "H", weight=8)
+        G.add_edge("B", "C", weight=8)
+        G.add_edge("B", "H", weight=11)
+        G.add_edge("C", "D", weight=7)
+        G.add_edge("C", "F", weight=4)
+        G.add_edge("C", "I", weight=2)
+        G.add_edge("D", "E", weight=9)
+        G.add_edge("D", "F", weight=14)
+        G.add_edge("E", "F", weight=10)
+        G.add_edge("F", "G", weight=2)
+        G.add_edge("G", "H", weight=1)
+        G.add_edge("G", "I", weight=6)
+        G.add_edge("H", "I", weight=7)
+
+        # Set default start and end nodes
+        start_node = "A"
+        end_node = "E"
+        st.write(f"Finding the shortest path from {start_node} to {end_node}")
+        plot_shortest_path(G, start_node, end_node)
+
+    elif graph_mode == "Create Your Own":
+        st.write("### Create Your Own Graph")
+
+        # Input for nodes
+        nodes_input = st.text_area("Enter nodes (e.g., A, B, C, D, E, F, G, H):")
+        edges_input = st.text_area("Enter edges with weights (e.g., (A, B, 4), (B, C, 8)):").strip()
+
+        # Input for start and end nodes
+        start_node = st.text_input("Enter start node (e.g., A):")
+        end_node = st.text_input("Enter end node (e.g., E):")
+
+        if st.button("Generate Graph"):
+            if nodes_input and edges_input and start_node and end_node:
+                try:
+                    # Parse the input for nodes and edges
+                    nodes = nodes_input.split(",")
+                    edges = [
+                        tuple(edge.strip()[1:-1].split(",") + [edge.strip().split(",")[-1]])
+                        for edge in edges_input.split("),")
+                    ]
+                    edges = [
+                        (edge[0], edge[1], int(edge[2])) for edge in edges if len(edge) == 3
+                    ]
+
+                    # Create the graph and add nodes and edges
+                    G = nx.Graph()
+                    G.add_nodes_from(nodes)
+                    G.add_weighted_edges_from(edges)
+
+                    st.write("Custom Graph:", G.edges())
+                    plot_shortest_path(G, start_node, end_node)
+
+                except Exception as e:
+                    st.error(f"Error creating the graph: {e}")
+            else:
+                st.error("Please enter valid nodes, edges, and start/end nodes.")
+
+if sidebar_option == "Algorithms: Find Shortest Path":
+    algorithms_shortest_path()
 
 def plot_greedy_coloring(graph):
     # Apply greedy coloring