commit BFS DFS

Labs/Lab01-Search/main.py

@@ -12,6 +12,6 @@
     al = str(sys.argv[2])
     if (len(sys.argv)==4):
         time_delay = int(sys.argv[4])
-    else: time_delay=500
+    else: time_delay=1000
     run(input, al, time_delay)
 

Labs/Lab01-Search/student_functions.py

@@ -1,115 +1,63 @@
 import numpy as np
 
+from collections import defaultdict, deque
+
 
 def BFS(matrix, start, end):
-    """
-    BFS algorithm:
-    Parameters:
-    ---------------------------
-    matrix: np array 
-        The graph's adjacency matrix
-    start: integer
-        starting node
-    end: integer
-        ending node
+    # Khởi tạo hàng đợi và từ điển để theo dõi các đỉnh đã thăm
+    queue = deque([start])
+    visited = {start: None}
+
+    while queue:
+        current_node = queue.popleft()
+
+        # Duyệt qua tất cả các đỉnh kề của đỉnh hiện tại
+        for neighbor, has_edge in enumerate(matrix[current_node]):
+            if has_edge and neighbor not in visited:
+                queue.append(neighbor)
+                visited[neighbor] = current_node
+    print(visited)
+    # Xây dựng đường đi từ điểm đích đến điểm bắt đầu
+    path = build_path(start, end, visited)
 
-    Returns
-    ---------------------
-    visited
-        The dictionary contains visited nodes, each key is a visited node,
-        each value is the adjacent node visited before it.
-    path: list
-        Founded path
-    """
-
-    path=[]
-    visited={}
-
-    node = start
-    visited.update({node: None})
+    print(path)
+    return visited, path
 
-    if node == end:
-        path.append(node)
-        return visited, path
-
-    frontier = []
-    frontier.append(node)
-    while frontier:
-        if not frontier:
-            path.append(end) #?
-            return visited, path
-
-        node = frontier.pop(0)
+def build_path(start, end, visited):
+    # Xây dựng đường đi từ điểm đích đến điểm bắt đầu sử dụng thông tin đã thăm
+    path = []
+    current_node = end
+    while current_node is not None:
+        path.append(current_node)
+        current_node = visited[current_node]
 
-        for i in range(len(matrix[node])):
-            if matrix[node][i] != 0 \
-            and i not in visited \
-            and i not in frontier:
-
-                if i == end:
-                    path.append(node)
-                    break
+    # Đảo ngược đường đi để có thứ tự đúng
+    path.reverse()
 
-                frontier.append(i)
-                visited.update({i: node})
-                path.append(frontier[0])
-
-
-    return visited, path
+    return path
 
 def DFS(matrix, start, end):
-    """
-    DFS algorithm
-     Parameters:
-    ---------------------------
-    matrix: np array 
-        The graph's adjacency matrix
-    start: integer 
-        starting node
-    end: integer
-        ending node
-
-    Returns
-    ---------------------
-    visited 
-        The dictionary contains visited nodes: each key is a visited node, 
-        each value is the key's adjacent node which is visited before key.
-    path: list
-        Founded path
-    """
-
+    # TODO:  
     path=[]
     visited={}
+
+    stack = deque([(start, 0)])  # Stack chứa cặp (đỉnh, chi phí)
 
-    node = start
-    visited.update({node: None})
+    while stack:
+        current, cost = stack.pop()
 
-    if node == end:
-        path.append(node)
-        return visited, path
-
-    frontier = []
-    frontier.append(node)
-    while frontier:
-        if not frontier:
-            path.append(end) #?
-            return visited, path
-
-        node = frontier.pop()
+        if current not in visited:
+            visited[current] = cost
+            path.append(current)
 
-        for i in range(len(matrix[node])):
-            if matrix[node][i] != 0 \
-            and i not in visited \
-            and i not in frontier:
-
-                if i == end:
-                    path.append(node)
-                    break
+            if current == end:
+                break  # Đã đến đích, kết thúc thuật toán
+
+            neighbors = np.nonzero(matrix[current])[0]
+            for neighbor in neighbors:
+                if neighbor not in visited:
+                    stack.append((neighbor, cost + matrix[current, neighbor]))
 
-                frontier.append(i)
-                visited.update({i: node})
-                path.append(frontier[0])
-
     return visited, path