Upload 47 files

.gitattributes

@@ -33,3 +33,37 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+flux_krea_00365_.png filter=lfs diff=lfs merge=lfs -text
+output.mp4 filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.06.15 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.10.05 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.22.11 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.22.40 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.25.29 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.25.52 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.27.57 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.29.58 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.30.13 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.32.24 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.32.39 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.34.30 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.34.44 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.37.29 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.37.40 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V0/V0[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]11.40.11 AM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.23.03 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.24.27 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.24.52 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.26.11 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.27.03 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.28.01 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.28.29 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.29.33 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.30.06 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.31.17 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.31.42 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.33.19 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.33.42 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.34.51 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.35.56 PM.png filter=lfs diff=lfs merge=lfs -text
+vacuum_simulation/V1/V1[[:space:]]Visualizations/Screenshot[[:space:]]2025-10-28[[:space:]]at[[:space:]]12.36.55 PM.png filter=lfs diff=lfs merge=lfs -text

output.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d5c3b365a459d04e8d1b3406f51e592a1cb8796839f4b744305b15971752727
+size 17767411

vacuum_simulation/V0/environment.py

@@ -0,0 +1,71 @@
+import random
+from enum import Enum
+
+class CellType(Enum):
+    CLEAN = 0
+    DIRTY = 1
+    OBSTACLE = 2
+    EXPLORED = 3
+
+class Direction(Enum):
+    UP = 0
+    RIGHT = 1
+    DOWN = 2
+    LEFT = 3
+
+class Environment:
+    def __init__(self, rows, cols, obstacle_density=0.2, dirt_density=0.3):
+        self.rows = rows
+        self.cols = cols
+        self.grid = [[CellType.CLEAN for _ in range(cols)] for _ in range(rows)]
+        self.obstacle_density = obstacle_density
+        self.dirt_density = dirt_density
+        self.vacuum_pos = None
+        self.dirty_cells = set()
+        
+        self.generate_environment()
+    
+    def generate_environment(self):
+        # Place obstacles
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if random.random() < self.obstacle_density:
+                    self.grid[i][j] = CellType.OBSTACLE
+        
+        # Place dirt
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if self.grid[i][j] == CellType.CLEAN and random.random() < self.dirt_density:
+                    self.grid[i][j] = CellType.DIRTY
+                    self.dirty_cells.add((i, j))
+        
+        # Place vacuum at a random clean position
+        clean_positions = [(i, j) for i in range(self.rows) for j in range(self.cols) 
+                          if self.grid[i][j] == CellType.CLEAN]
+        if clean_positions:
+            self.vacuum_pos = random.choice(clean_positions)
+    
+    def reset(self):
+        self.grid = [[CellType.CLEAN for _ in range(self.cols)] for _ in range(self.rows)]
+        self.dirty_cells = set()
+        self.generate_environment()
+    
+    def is_valid_position(self, row, col):
+        return 0 <= row < self.rows and 0 <= col < self.cols and self.grid[row][col] != CellType.OBSTACLE
+    
+    def clean_cell(self, row, col):
+        if (row, col) in self.dirty_cells:
+            self.grid[row][col] = CellType.CLEAN
+            self.dirty_cells.remove((row, col))
+            return True
+        return False
+    
+    def mark_explored(self, row, col):
+        if self.grid[row][col] == CellType.CLEAN:
+            self.grid[row][col] = CellType.EXPLORED
+    
+    def get_dirty_count(self):
+        return len(self.dirty_cells)
+    
+    def is_clean(self):
+        return len(self.dirty_cells) == 0

vacuum_simulation/V0/main.py

@@ -0,0 +1,20 @@
+import sys
+import random
+from PyQt5.QtWidgets import QApplication
+from vacuum_simulation import VacuumSimulation
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    
+    # Default grid size or use command line arguments
+    rows, cols = 15, 15
+    if len(sys.argv) >= 3:
+        try:
+            rows, cols = int(sys.argv[1]), int(sys.argv[2])
+        except ValueError:
+            print("Invalid grid dimensions. Using default 15x15.")
+    
+    window = VacuumSimulation(rows, cols)
+    window.show()
+    
+    sys.exit(app.exec_())

vacuum_simulation/V0/search_algorithms.py

@@ -0,0 +1,178 @@
+import heapq
+import math
+from collections import deque
+from environment import Direction
+
+class Node:
+    def __init__(self, position, parent=None, direction=None):
+        self.position = position
+        self.parent = parent
+        self.direction = direction
+        self.g = 0  # Cost from start to current node
+        self.h = 0  # Heuristic cost from current node to goal
+        self.f = 0  # Total cost (g + h)
+    
+    def __eq__(self, other):
+        return self.position == other.position
+    
+    def __lt__(self, other):
+        return self.f < other.f
+
+class SearchAlgorithms:
+    def __init__(self, environment, turn_cost_enabled=False):
+        self.env = environment
+        self.turn_cost_enabled = turn_cost_enabled
+    
+    def get_neighbors(self, position, direction=None):
+        row, col = position
+        neighbors = []
+        
+        # Possible moves: up, right, down, left
+        moves = [(-1, 0, Direction.UP), (0, 1, Direction.RIGHT), 
+                 (1, 0, Direction.DOWN), (0, -1, Direction.LEFT)]
+        
+        for dr, dc, new_dir in moves:
+            new_row, new_col = row + dr, col + dc
+            if self.env.is_valid_position(new_row, new_col):
+                turn_cost = 0
+                if self.turn_cost_enabled and direction is not None and direction != new_dir:
+                    # Calculate turn cost (0.5 for 90° turns)
+                    turn_cost = 0.5
+                
+                neighbors.append(((new_row, new_col), new_dir, 1 + turn_cost))
+        
+        return neighbors
+    
+    def get_diagonal_neighbors(self, position, direction=None):
+        row, col = position
+        neighbors = []
+        
+        # Possible moves including diagonals
+        moves = [
+            (-1, 0, Direction.UP, 1), (0, 1, Direction.RIGHT, 1), 
+            (1, 0, Direction.DOWN, 1), (0, -1, Direction.LEFT, 1),
+            (-1, -1, None, math.sqrt(2)), (-1, 1, None, math.sqrt(2)),
+            (1, -1, None, math.sqrt(2)), (1, 1, None, math.sqrt(2))
+        ]
+        
+        for dr, dc, new_dir, cost in moves:
+            new_row, new_col = row + dr, col + dc
+            if self.env.is_valid_position(new_row, new_col):
+                turn_cost = 0
+                if self.turn_cost_enabled and direction is not None and direction != new_dir and new_dir is not None:
+                    turn_cost = 0.5
+                
+                neighbors.append(((new_row, new_col), new_dir, cost + turn_cost))
+        
+        return neighbors
+    
+    def manhattan_distance(self, pos1, pos2):
+        return abs(pos1[0] - pos2[0]) + abs(pos1[1] - pos2[1])
+    
+    def euclidean_distance(self, pos1, pos2):
+        return math.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)
+    
+    def chebyshev_distance(self, pos1, pos2):
+        return max(abs(pos1[0] - pos2[0]), abs(pos1[1] - pos2[1]))
+    
+    def bfs(self, start, goals):
+        """Breadth-First Search"""
+        if not goals:
+            return None, set()
+            
+        queue = deque([Node(start)])
+        visited = set([start])
+        explored = set([start])
+        
+        while queue:
+            current_node = queue.popleft()
+            
+            # Check if we reached any goal
+            if current_node.position in goals:
+                path = []
+                while current_node:
+                    path.append(current_node.position)
+                    current_node = current_node.parent
+                return path[::-1], explored
+            
+            for neighbor, _, _ in self.get_neighbors(current_node.position):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    explored.add(neighbor)
+                    queue.append(Node(neighbor, current_node))
+        
+        return None, explored
+    
+    def a_star(self, start, goals, heuristic_type="manhattan", allow_diagonals=False):
+        """A* Search with different heuristics"""
+        if not goals:
+            return None, set()
+            
+        open_list = []
+        heapq.heappush(open_list, Node(start))
+        closed_list = set()
+        explored = set([start])
+        
+        # Cost from start to node
+        g_costs = {start: 0}
+        
+        while open_list:
+            current_node = heapq.heappop(open_list)
+            
+            # Check if we reached any goal
+            if current_node.position in goals:
+                path = []
+                while current_node:
+                    path.append(current_node.position)
+                    current_node = current_node.parent
+                return path[::-1], explored
+            
+            closed_list.add(current_node.position)
+            
+            # Get neighbors based on whether diagonals are allowed
+            if allow_diagonals:
+                neighbors = self.get_diagonal_neighbors(current_node.position, current_node.direction)
+            else:
+                neighbors = self.get_neighbors(current_node.position, current_node.direction)
+            
+            for neighbor_pos, direction, move_cost in neighbors:
+                if neighbor_pos in closed_list:
+                    continue
+                
+                # Calculate new g cost
+                new_g = g_costs[current_node.position] + move_cost
+                
+                if neighbor_pos not in g_costs or new_g < g_costs[neighbor_pos]:
+                    # Calculate heuristic to the closest goal
+                    min_h = float('inf')
+                    for goal in goals:
+                        if heuristic_type == "manhattan":
+                            h = self.manhattan_distance(neighbor_pos, goal)
+                        elif heuristic_type == "euclidean":
+                            h = self.euclidean_distance(neighbor_pos, goal)
+                        elif heuristic_type == "chebyshev":
+                            h = self.chebyshev_distance(neighbor_pos, goal)
+                        min_h = min(min_h, h)
+                    
+                    # Create new node
+                    new_node = Node(neighbor_pos, current_node, direction)
+                    new_node.g = new_g
+                    new_node.h = min_h
+                    new_node.f = new_g + min_h
+                    
+                    g_costs[neighbor_pos] = new_g
+                    explored.add(neighbor_pos)
+                    heapq.heappush(open_list, new_node)
+        
+        return None, explored
+    
+    def find_path_to_nearest_dirty(self, vacuum_pos, algorithm="a_star", heuristic="manhattan"):
+        """Find path to the nearest dirty cell"""
+        dirty_cells = list(self.env.dirty_cells)
+        
+        if algorithm == "bfs":
+            return self.bfs(vacuum_pos, dirty_cells)
+        else:
+            # For A*, we need to decide whether to allow diagonals based on heuristic
+            allow_diagonals = heuristic in ["euclidean", "chebyshev"]
+            return self.a_star(vacuum_pos, dirty_cells, heuristic, allow_diagonals)

vacuum_simulation/V0/vacuum_simulation.py

@@ -0,0 +1,339 @@
+import sys
+import time
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, 
+                             QPushButton, QComboBox, QCheckBox, QLabel, QWidget, QGridLayout,
+                             QFrame)
+from PyQt5.QtCore import QTimer, Qt
+from PyQt5.QtGui import QColor, QPainter, QBrush, QFont, QPen
+
+from environment import Environment, CellType
+from search_algorithms import SearchAlgorithms
+
+class GridWidget(QWidget):
+    def __init__(self, rows, cols, cell_size, environment):
+        super().__init__()
+        self.rows = rows
+        self.cols = cols
+        self.cell_size = cell_size
+        self.env = environment
+        self.current_path = []
+        self.current_direction = None
+        
+        self.setFixedSize(cols * cell_size, rows * cell_size)
+    
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        
+        # Draw grid cells
+        for row in range(self.rows):
+            for col in range(self.cols):
+                x = col * self.cell_size
+                y = row * self.cell_size
+                
+                # Determine cell color based on type
+                cell_type = self.env.grid[row][col]
+                if cell_type == CellType.CLEAN:
+                    color = QColor(255, 255, 0)  # Yellow
+                elif cell_type == CellType.DIRTY:
+                    color = QColor(255, 0, 0)    # Red
+                elif cell_type == CellType.OBSTACLE:
+                    color = QColor(0, 0, 255)    # Blue
+                elif cell_type == CellType.EXPLORED:
+                    color = QColor(0, 255, 0)    # Green
+                
+                # Draw cell
+                painter.fillRect(x, y, self.cell_size, self.cell_size, color)
+                painter.setPen(Qt.black)
+                painter.drawRect(x, y, self.cell_size, self.cell_size)
+        
+        # Draw path
+        if self.current_path:
+            painter.setPen(QPen(QColor(255, 165, 0), 2))  # Orange
+            painter.setBrush(QBrush(QColor(255, 165, 0)))
+            
+            for i in range(len(self.current_path) - 1):
+                row1, col1 = self.current_path[i]
+                row2, col2 = self.current_path[i + 1]
+                
+                x1 = col1 * self.cell_size + self.cell_size // 2
+                y1 = row1 * self.cell_size + self.cell_size // 2
+                x2 = col2 * self.cell_size + self.cell_size // 2
+                y2 = row2 * self.cell_size + self.cell_size // 2
+                
+                painter.drawLine(x1, y1, x2, y2)
+            
+            # Draw path nodes
+            for row, col in self.current_path:
+                x = col * self.cell_size + self.cell_size // 2
+                y = row * self.cell_size + self.cell_size // 2
+                painter.drawEllipse(x - 3, y - 3, 6, 6)
+        
+        # Draw vacuum
+        if self.env.vacuum_pos:
+            row, col = self.env.vacuum_pos
+            x = col * self.cell_size
+            y = row * self.cell_size
+            
+            painter.setPen(Qt.black)
+            painter.setBrush(QBrush(Qt.white))
+            painter.drawEllipse(x + 5, y + 5, self.cell_size - 10, self.cell_size - 10)
+            
+            # Draw direction indicator
+            if self.current_direction is not None:
+                center_x = x + self.cell_size // 2
+                center_y = y + self.cell_size // 2
+                
+                if self.current_direction.value == 0:  # UP
+                    painter.drawLine(center_x, center_y, center_x, y + 5)
+                elif self.current_direction.value == 1:  # RIGHT
+                    painter.drawLine(center_x, center_y, x + self.cell_size - 5, center_y)
+                elif self.current_direction.value == 2:  # DOWN
+                    painter.drawLine(center_x, center_y, center_x, y + self.cell_size - 5)
+                elif self.current_direction.value == 3:  # LEFT
+                    painter.drawLine(center_x, center_y, x + 5, center_y)
+    
+    def update_path(self, path, direction):
+        self.current_path = path
+        self.current_direction = direction
+        self.update()
+
+class VacuumSimulation(QMainWindow):
+    def __init__(self, rows=15, cols=15):
+        super().__init__()
+        self.rows = rows
+        self.cols = cols
+        self.cell_size = 30
+        self.env = Environment(rows, cols)
+        self.search = SearchAlgorithms(self.env)
+        
+        # Simulation state
+        self.current_path = []
+        self.explored_cells = set()
+        self.steps_taken = 0
+        self.total_cost = 0
+        self.current_direction = None
+        self.is_running = False
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.next_step)
+        
+        self.init_ui()
+        self.update_display()
+    
+    def init_ui(self):
+        self.setWindowTitle("Vacuum Cleaner Search Simulation")
+        self.setFixedSize(self.cols * self.cell_size + 300, self.rows * self.cell_size + 150)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        
+        # Main layout
+        main_layout = QVBoxLayout()
+        central_widget.setLayout(main_layout)
+        
+        # Metrics display
+        metrics_layout = QHBoxLayout()
+        self.steps_label = QLabel("Steps: 0")
+        self.cost_label = QLabel("Total Cost: 0.0")
+        self.dirty_label = QLabel("Dirty Cells: 0")
+        self.nodes_explored_label = QLabel("Nodes Explored: 0")
+        
+        # Set fixed width for metrics to prevent layout shifting
+        self.steps_label.setFixedWidth(120)
+        self.cost_label.setFixedWidth(120)
+        self.dirty_label.setFixedWidth(120)
+        self.nodes_explored_label.setFixedWidth(140)
+        
+        metrics_layout.addWidget(self.steps_label)
+        metrics_layout.addWidget(self.cost_label)
+        metrics_layout.addWidget(self.dirty_label)
+        metrics_layout.addWidget(self.nodes_explored_label)
+        metrics_layout.addStretch()
+        
+        main_layout.addLayout(metrics_layout)
+        
+        # Control panel
+        control_layout = QHBoxLayout()
+        
+        # Reset button
+        self.reset_button = QPushButton("Reset")
+        self.reset_button.clicked.connect(self.reset_simulation)
+        control_layout.addWidget(self.reset_button)
+        
+        # Next button
+        self.next_button = QPushButton("Next")
+        self.next_button.clicked.connect(self.next_step)
+        control_layout.addWidget(self.next_button)
+        
+        # Run button
+        self.run_button = QPushButton("Run")
+        self.run_button.clicked.connect(self.toggle_run)
+        control_layout.addWidget(self.run_button)
+        
+        # Turn cost checkbox
+        self.turn_cost_checkbox = QCheckBox("Turn Cost (0.5 per 90° turn)")
+        self.turn_cost_checkbox.stateChanged.connect(self.toggle_turn_cost)
+        control_layout.addWidget(self.turn_cost_checkbox)
+        
+        # Search algorithm dropdown
+        control_layout.addWidget(QLabel("Search:"))
+        self.search_combo = QComboBox()
+        self.search_combo.addItems(["BFS", "A* Manhattan", "A* Euclidean", "A* Chebyshev"])
+        control_layout.addWidget(self.search_combo)
+        
+        control_layout.addStretch()
+        main_layout.addLayout(control_layout)
+        
+        # Grid display
+        self.grid_widget = GridWidget(self.rows, self.cols, self.cell_size, self.env)
+        main_layout.addWidget(self.grid_widget)
+        
+        # Legend
+        legend_layout = QHBoxLayout()
+        
+        def create_legend_item(color, text):
+            item_widget = QWidget()
+            item_layout = QHBoxLayout()
+            item_widget.setLayout(item_layout)
+            
+            color_label = QLabel()
+            color_label.setFixedSize(20, 20)
+            color_label.setStyleSheet(f"background-color: {color}; border: 1px solid black")
+            item_layout.addWidget(color_label)
+            
+            text_label = QLabel(text)
+            item_layout.addWidget(text_label)
+            item_layout.setContentsMargins(5, 0, 10, 0)
+            
+            return item_widget
+        
+        legend_layout.addWidget(create_legend_item("yellow", "Clean"))
+        legend_layout.addWidget(create_legend_item("red", "Dirty"))
+        legend_layout.addWidget(create_legend_item("blue", "Obstacle"))
+        legend_layout.addWidget(create_legend_item("green", "Explored"))
+        legend_layout.addWidget(create_legend_item("orange", "Path"))
+        legend_layout.addStretch()
+        
+        main_layout.addLayout(legend_layout)
+    
+    def update_display(self):
+        self.steps_label.setText(f"Steps: {self.steps_taken}")
+        self.cost_label.setText(f"Total Cost: {self.total_cost:.2f}")
+        self.dirty_label.setText(f"Dirty Cells: {self.env.get_dirty_count()}")
+        self.nodes_explored_label.setText(f"Nodes Explored: {len(self.explored_cells)}")
+        self.grid_widget.update_path(self.current_path, self.current_direction)
+    
+    def reset_simulation(self):
+        self.env.reset()
+        self.current_path = []
+        self.explored_cells = set()
+        self.steps_taken = 0
+        self.total_cost = 0
+        self.current_direction = None
+        self.is_running = False
+        self.timer.stop()
+        self.run_button.setText("Run")
+        self.update_display()
+    
+    def next_step(self):
+        if self.env.is_clean():
+            self.is_running = False
+            self.timer.stop()
+            self.run_button.setText("Run")
+            return
+        
+        # If we don't have a path, find one
+        if not self.current_path:
+            self.find_path()
+        
+        # If we have a path, move along it
+        if self.current_path:
+            # Move to next position in path
+            next_pos = self.current_path.pop(0)
+            
+            # Calculate movement cost
+            move_cost = 1
+            if self.turn_cost_checkbox.isChecked() and self.current_direction is not None:
+                # Determine if we turned
+                current_row, current_col = self.env.vacuum_pos
+                next_row, next_col = next_pos
+                
+                # Determine new direction
+                if next_row < current_row:
+                    new_direction = 0  # UP
+                elif next_row > current_row:
+                    new_direction = 2  # DOWN
+                elif next_col > current_col:
+                    new_direction = 1  # RIGHT
+                else:
+                    new_direction = 3  # LEFT
+                
+                # Add turn cost if direction changed
+                if self.current_direction.value != new_direction:
+                    move_cost += 0.5
+                
+                self.current_direction = new_direction
+            
+            # Update vacuum position
+            self.env.vacuum_pos = next_pos
+            self.steps_taken += 1
+            self.total_cost += move_cost
+            
+            # Clean the cell if it's dirty
+            if self.env.clean_cell(next_pos[0], next_pos[1]):
+                # If we cleaned a cell, we need to find a new path
+                self.current_path = []
+            
+            # Mark cell as explored
+            self.env.mark_explored(next_pos[0], next_pos[1])
+        
+        self.update_display()
+    
+    def find_path(self):
+        # Get selected search algorithm
+        search_type = self.search_combo.currentText()
+        
+        if search_type == "BFS":
+            algorithm = "bfs"
+            heuristic = "manhattan"
+        else:
+            algorithm = "a_star"
+            if search_type == "A* Manhattan":
+                heuristic = "manhattan"
+            elif search_type == "A* Euclidean":
+                heuristic = "euclidean"
+            else:  # A* Chebyshev
+                heuristic = "chebyshev"
+        
+        # Update search algorithm with current turn cost setting
+        self.search.turn_cost_enabled = self.turn_cost_checkbox.isChecked()
+        
+        # Find path to nearest dirty cell
+        self.current_path, explored = self.search.find_path_to_nearest_dirty(
+            self.env.vacuum_pos, algorithm, heuristic)
+        
+        if self.current_path:
+            # Remove current position from path
+            self.current_path = self.current_path[1:]
+            self.explored_cells.update(explored)
+            
+            # Mark explored cells
+            for row, col in explored:
+                if (row, col) != self.env.vacuum_pos and self.env.grid[row][col] == CellType.CLEAN:
+                    self.env.grid[row][col] = CellType.EXPLORED
+    
+    def toggle_run(self):
+        self.is_running = not self.is_running
+        
+        if self.is_running:
+            self.run_button.setText("Pause")
+            self.timer.start(1000)  # 1 second interval
+        else:
+            self.run_button.setText("Run")
+            self.timer.stop()
+    
+    def toggle_turn_cost(self):
+        # When turn cost is toggled, we need to recalculate the path
+        if self.current_path:
+            self.current_path = []

vacuum_simulation/environment.py

@@ -0,0 +1,89 @@
+import random
+from enum import Enum
+
+class CellType(Enum):
+    CLEAN = 0
+    DIRTY = 1
+    OBSTACLE = 2
+    EXPLORED = 3
+
+class Direction(Enum):
+    UP = 0
+    RIGHT = 1
+    DOWN = 2
+    LEFT = 3
+    
+    @classmethod
+    def from_movement(cls, current_pos, next_pos):
+        """Determine direction from current position to next position"""
+        current_row, current_col = current_pos
+        next_row, next_col = next_pos
+        
+        if next_row < current_row:
+            return cls.UP
+        elif next_row > current_row:
+            return cls.DOWN
+        elif next_col > current_col:
+            return cls.RIGHT
+        elif next_col < current_col:
+            return cls.LEFT
+        return None
+
+class Environment:
+    def __init__(self, rows, cols, obstacle_density=0.2, dirt_density=0.3):
+        self.rows = rows
+        self.cols = cols
+        self.grid = [[CellType.CLEAN for _ in range(cols)] for _ in range(rows)]
+        self.obstacle_density = obstacle_density
+        self.dirt_density = dirt_density
+        self.vacuum_pos = None
+        self.dirty_cells = set()
+        
+        self.generate_environment()
+    
+    def generate_environment(self):
+        # Place obstacles
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if random.random() < self.obstacle_density:
+                    self.grid[i][j] = CellType.OBSTACLE
+        
+        # Place dirt on clean cells only
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if self.grid[i][j] == CellType.CLEAN and random.random() < self.dirt_density:
+                    self.grid[i][j] = CellType.DIRTY
+                    self.dirty_cells.add((i, j))
+        
+        # Place vacuum at a random clean position
+        clean_positions = [(i, j) for i in range(self.rows) for j in range(self.cols) 
+                          if self.grid[i][j] == CellType.CLEAN]
+        if clean_positions:
+            self.vacuum_pos = random.choice(clean_positions)
+    
+    def reset(self):
+        self.grid = [[CellType.CLEAN for _ in range(self.cols)] for _ in range(self.rows)]
+        self.dirty_cells = set()
+        self.generate_environment()
+    
+    def is_valid_position(self, row, col):
+        return (0 <= row < self.rows and 
+                0 <= col < self.cols and 
+                self.grid[row][col] != CellType.OBSTACLE)
+    
+    def clean_cell(self, row, col):
+        if (row, col) in self.dirty_cells:
+            self.grid[row][col] = CellType.CLEAN
+            self.dirty_cells.remove((row, col))
+            return True
+        return False
+    
+    def mark_explored(self, row, col):
+        if self.grid[row][col] == CellType.CLEAN:
+            self.grid[row][col] = CellType.EXPLORED
+    
+    def get_dirty_count(self):
+        return len(self.dirty_cells)
+    
+    def is_clean(self):
+        return len(self.dirty_cells) == 0

vacuum_simulation/main.py

@@ -0,0 +1,20 @@
+import sys
+import random
+from PyQt5.QtWidgets import QApplication
+from vacuum_simulation import VacuumSimulation
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    
+    # Default grid size or use command line arguments
+    rows, cols = 15, 15
+    if len(sys.argv) >= 3:
+        try:
+            rows, cols = int(sys.argv[1]), int(sys.argv[2])
+        except ValueError:
+            print("Invalid grid dimensions. Using default 15x15.")
+    
+    window = VacuumSimulation(rows, cols)
+    window.show()
+    
+    sys.exit(app.exec_())

vacuum_simulation/requirements.txt

@@ -0,0 +1 @@
+PyQt5

vacuum_simulation/search_algorithms.py

@@ -0,0 +1,224 @@
+import heapq
+import math
+import time
+from collections import deque
+from environment import Direction
+
+class Node:
+    def __init__(self, position, parent=None, direction=None):
+        self.position = position
+        self.parent = parent
+        self.direction = direction  # This should be a Direction enum
+        self.g = 0  # Cost from start to current node
+        self.h = 0  # Heuristic cost from current node to goal
+        self.f = 0  # Total cost (g + h)
+    
+    def __eq__(self, other):
+        return self.position == other.position
+    
+    def __lt__(self, other):
+        return self.f < other.f
+
+class SearchAlgorithms:
+    def __init__(self, environment, turn_cost_enabled=False):
+        self.env = environment
+        self.turn_cost_enabled = turn_cost_enabled
+    
+    def calculate_turn_cost(self, current_dir, new_dir):
+        """Calculate turn cost between directions (0.5 for 90° turns)"""
+        if not self.turn_cost_enabled or current_dir is None or new_dir is None:
+            return 0
+        
+        if current_dir == new_dir:
+            return 0
+        
+        # Calculate the absolute difference in direction values
+        diff = abs(current_dir.value - new_dir.value)
+        
+        # For 4-direction system, handle wrap-around (UP=0, LEFT=3)
+        if diff == 3:  # This means UP to LEFT or LEFT to UP
+            diff = 1
+        
+        if diff == 1:  # 90° turn
+            return 0.5
+        elif diff == 2:  # 180° turn
+            return 1.0
+        return 0
+    
+    def get_neighbors(self, position, direction=None):
+        row, col = position
+        neighbors = []
+        
+        # Possible moves: up, right, down, left
+        moves = [
+            (-1, 0, Direction.UP), 
+            (0, 1, Direction.RIGHT), 
+            (1, 0, Direction.DOWN), 
+            (0, -1, Direction.LEFT)
+        ]
+        
+        for dr, dc, new_dir in moves:
+            new_row, new_col = row + dr, col + dc
+            if self.env.is_valid_position(new_row, new_col):
+                turn_cost = self.calculate_turn_cost(direction, new_dir)
+                move_cost = 1 + turn_cost
+                neighbors.append(((new_row, new_col), new_dir, move_cost))
+        
+        return neighbors
+    
+    def get_diagonal_neighbors(self, position, direction=None):
+        row, col = position
+        neighbors = []
+        
+        # Possible moves including diagonals
+        moves = [
+            (-1, 0, Direction.UP, 1), 
+            (0, 1, Direction.RIGHT, 1), 
+            (1, 0, Direction.DOWN, 1), 
+            (0, -1, Direction.LEFT, 1),
+            (-1, -1, Direction.UP, math.sqrt(2)), 
+            (-1, 1, Direction.UP, math.sqrt(2)),
+            (1, -1, Direction.DOWN, math.sqrt(2)), 
+            (1, 1, Direction.DOWN, math.sqrt(2))
+        ]
+        
+        for dr, dc, new_dir, base_cost in moves:
+            new_row, new_col = row + dr, col + dc
+            if self.env.is_valid_position(new_row, new_col):
+                turn_cost = self.calculate_turn_cost(direction, new_dir)
+                move_cost = base_cost + turn_cost
+                neighbors.append(((new_row, new_col), new_dir, move_cost))
+        
+        return neighbors
+    
+    def manhattan_distance(self, pos1, pos2):
+        return abs(pos1[0] - pos2[0]) + abs(pos1[1] - pos2[1])
+    
+    def euclidean_distance(self, pos1, pos2):
+        return math.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)
+    
+    def chebyshev_distance(self, pos1, pos2):
+        return max(abs(pos1[0] - pos2[0]), abs(pos1[1] - pos2[1]))
+    
+    def bfs(self, start, goals):
+        """Breadth-First Search"""
+        start_time = time.time()
+        if not goals:
+            return None, set(), 0, 0
+            
+        queue = deque([Node(start)])
+        visited = set([start])
+        explored = set([start])
+        nodes_expanded = 0
+        
+        while queue:
+            current_node = queue.popleft()
+            nodes_expanded += 1
+            
+            # Check if we reached any goal
+            if current_node.position in goals:
+                path = []
+                temp_node = current_node
+                while temp_node:
+                    path.append(temp_node.position)
+                    temp_node = temp_node.parent
+                computation_time = time.time() - start_time
+                return path[::-1], explored, nodes_expanded, computation_time
+            
+            for neighbor_pos, new_dir, move_cost in self.get_neighbors(current_node.position):
+                if neighbor_pos not in visited:
+                    visited.add(neighbor_pos)
+                    explored.add(neighbor_pos)
+                    new_node = Node(neighbor_pos, current_node, new_dir)
+                    queue.append(new_node)
+        
+        computation_time = time.time() - start_time
+        return None, explored, nodes_expanded, computation_time
+    
+    def a_star(self, start, goals, heuristic_type="manhattan", allow_diagonals=False):
+        """A* Search with different heuristics"""
+        start_time = time.time()
+        if not goals:
+            return None, set(), 0, 0
+            
+        open_list = []
+        start_node = Node(start)
+        heapq.heappush(open_list, start_node)
+        closed_list = set()
+        explored = set([start])
+        nodes_expanded = 0
+        
+        # Cost from start to node
+        g_costs = {start: 0}
+        # Keep track of directions for turn cost calculation
+        directions = {start: None}
+        
+        while open_list:
+            current_node = heapq.heappop(open_list)
+            nodes_expanded += 1
+            
+            # Check if we reached any goal
+            if current_node.position in goals:
+                path = []
+                temp_node = current_node
+                while temp_node:
+                    path.append(temp_node.position)
+                    temp_node = temp_node.parent
+                computation_time = time.time() - start_time
+                return path[::-1], explored, nodes_expanded, computation_time
+            
+            closed_list.add(current_node.position)
+            current_dir = directions[current_node.position]
+            
+            # Get neighbors based on whether diagonals are allowed
+            if allow_diagonals:
+                neighbors = self.get_diagonal_neighbors(current_node.position, current_dir)
+            else:
+                neighbors = self.get_neighbors(current_node.position, current_dir)
+            
+            for neighbor_pos, direction, move_cost in neighbors:
+                if neighbor_pos in closed_list:
+                    continue
+                
+                # Calculate new g cost
+                new_g = g_costs[current_node.position] + move_cost
+                
+                if neighbor_pos not in g_costs or new_g < g_costs[neighbor_pos]:
+                    # Calculate heuristic to the closest goal
+                    min_h = float('inf')
+                    for goal in goals:
+                        if heuristic_type == "manhattan":
+                            h = self.manhattan_distance(neighbor_pos, goal)
+                        elif heuristic_type == "euclidean":
+                            h = self.euclidean_distance(neighbor_pos, goal)
+                        elif heuristic_type == "chebyshev":
+                            h = self.chebyshev_distance(neighbor_pos, goal)
+                        min_h = min(min_h, h)
+                    
+                    # Create new node
+                    new_node = Node(neighbor_pos, current_node, direction)
+                    new_node.g = new_g
+                    new_node.h = min_h
+                    new_node.f = new_g + min_h
+                    
+                    g_costs[neighbor_pos] = new_g
+                    directions[neighbor_pos] = direction
+                    explored.add(neighbor_pos)
+                    heapq.heappush(open_list, new_node)
+        
+        computation_time = time.time() - start_time
+        return None, explored, nodes_expanded, computation_time
+    
+    def find_path_to_nearest_dirty(self, vacuum_pos, algorithm="a_star", heuristic="manhattan"):
+        """Find path to the nearest dirty cell"""
+        dirty_cells = list(self.env.dirty_cells)
+        
+        if not dirty_cells:
+            return None, set(), 0, 0
+        
+        if algorithm == "bfs":
+            return self.bfs(vacuum_pos, dirty_cells)
+        else:
+            # For A*, we need to decide whether to allow diagonals based on heuristic
+            allow_diagonals = heuristic in ["euclidean", "chebyshev"]
+            return self.a_star(vacuum_pos, dirty_cells, heuristic, allow_diagonals)

vacuum_simulation/vacuum_simulation.py

@@ -0,0 +1,523 @@
+import sys
+import time
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, 
+                             QPushButton, QComboBox, QCheckBox, QLabel, QWidget, 
+                             QTextEdit, QSplitter, QFrame)
+from PyQt5.QtCore import QTimer, Qt
+from PyQt5.QtGui import QColor, QPainter, QBrush, QPen
+
+from environment import Environment, CellType, Direction
+from search_algorithms import SearchAlgorithms
+
+class GridWidget(QWidget):
+    def __init__(self, rows, cols, cell_size, environment):
+        super().__init__()
+        self.rows = rows
+        self.cols = cols
+        self.cell_size = cell_size
+        self.env = environment
+        self.current_path = []
+        self.current_direction = None
+        
+        self.setFixedSize(cols * cell_size, rows * cell_size)
+    
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        
+        # Draw grid cells
+        for row in range(self.rows):
+            for col in range(self.cols):
+                x = col * self.cell_size
+                y = row * self.cell_size
+                
+                # Determine cell color based on type
+                cell_type = self.env.grid[row][col]
+                if cell_type == CellType.CLEAN:
+                    color = QColor(255, 255, 0)  # Yellow
+                elif cell_type == CellType.DIRTY:
+                    color = QColor(255, 0, 0)    # Red
+                elif cell_type == CellType.OBSTACLE:
+                    color = QColor(0, 0, 255)    # Blue
+                elif cell_type == CellType.EXPLORED:
+                    color = QColor(0, 255, 0)    # Green
+                
+                # Draw cell
+                painter.fillRect(x, y, self.cell_size, self.cell_size, color)
+                painter.setPen(Qt.black)
+                painter.drawRect(x, y, self.cell_size, self.cell_size)
+        
+        # Draw path
+        if self.current_path:
+            painter.setPen(QPen(QColor(255, 165, 0), 3))  # Orange, thicker line
+            painter.setBrush(QBrush(QColor(255, 165, 0)))
+            
+            # Draw path lines
+            for i in range(len(self.current_path) - 1):
+                row1, col1 = self.current_path[i]
+                row2, col2 = self.current_path[i + 1]
+                
+                x1 = col1 * self.cell_size + self.cell_size // 2
+                y1 = row1 * self.cell_size + self.cell_size // 2
+                x2 = col2 * self.cell_size + self.cell_size // 2
+                y2 = row2 * self.cell_size + self.cell_size // 2
+                
+                painter.drawLine(x1, y1, x2, y2)
+            
+            # Draw path nodes (larger dots)
+            for i, (row, col) in enumerate(self.current_path):
+                x = col * self.cell_size + self.cell_size // 2
+                y = row * self.cell_size + self.cell_size // 2
+                
+                # Make start and end points different
+                if i == 0:  # Start
+                    painter.setBrush(QBrush(QColor(0, 255, 0)))  # Green
+                    radius = 6
+                elif i == len(self.current_path) - 1:  # End
+                    painter.setBrush(QBrush(QColor(255, 0, 0)))  # Red
+                    radius = 6
+                else:  # Intermediate
+                    painter.setBrush(QBrush(QColor(255, 165, 0)))  # Orange
+                    radius = 4
+                
+                painter.drawEllipse(x - radius, y - radius, radius * 2, radius * 2)
+        
+        # Draw vacuum
+        if self.env.vacuum_pos:
+            row, col = self.env.vacuum_pos
+            x = col * self.cell_size
+            y = row * self.cell_size
+            
+            # Draw vacuum as a circle with direction indicator
+            painter.setPen(QPen(Qt.black, 2))
+            painter.setBrush(QBrush(Qt.white))
+            painter.drawEllipse(x + 5, y + 5, self.cell_size - 10, self.cell_size - 10)
+            
+            # Draw direction indicator
+            if self.current_direction is not None:
+                center_x = x + self.cell_size // 2
+                center_y = y + self.cell_size // 2
+                
+                # Thicker direction indicator
+                direction_pen = QPen(Qt.black, 3)
+                painter.setPen(direction_pen)
+                
+                # Use the Direction enum properly
+                if self.current_direction == Direction.UP:
+                    painter.drawLine(center_x, center_y + 5, center_x, y + 5)
+                elif self.current_direction == Direction.RIGHT:
+                    painter.drawLine(center_x - 5, center_y, x + self.cell_size - 5, center_y)
+                elif self.current_direction == Direction.DOWN:
+                    painter.drawLine(center_x, center_y - 5, center_x, y + self.cell_size - 5)
+                elif self.current_direction == Direction.LEFT:
+                    painter.drawLine(center_x + 5, center_y, x + 5, center_y)
+    
+    def update_path(self, path, direction):
+        self.current_path = path
+        self.current_direction = direction
+        self.update()
+
+class VacuumSimulation(QMainWindow):
+    def __init__(self, rows=15, cols=15):
+        super().__init__()
+        self.rows = rows
+        self.cols = cols
+        self.cell_size = 30
+        self.env = Environment(rows, cols)
+        self.search = SearchAlgorithms(self.env)
+        
+        # Simulation state
+        self.current_path = []
+        self.explored_cells = set()
+        self.steps_taken = 0
+        self.total_cost = 0
+        self.current_direction = None
+        self.is_running = False
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.next_step)
+        
+        # Performance metrics
+        self.total_nodes_expanded = 0
+        self.total_computation_time = 0
+        self.algorithm_stats = {
+            "BFS": {"runs": 0, "total_nodes": 0, "total_time": 0},
+            "A* Manhattan": {"runs": 0, "total_nodes": 0, "total_time": 0},
+            "A* Euclidean": {"runs": 0, "total_nodes": 0, "total_time": 0},
+            "A* Chebyshev": {"runs": 0, "total_nodes": 0, "total_time": 0}
+        }
+        
+        self.init_ui()
+        self.update_display()
+    
+    def init_ui(self):
+        self.setWindowTitle("Vacuum Cleaner Search Simulation - Algorithm Comparison")
+        
+        # Use a larger window to accommodate side panel
+        grid_width = self.cols * self.cell_size
+        grid_height = self.rows * self.cell_size
+        self.setMinimumSize(grid_width + 400, grid_height + 200)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        
+        # Main layout using splitter for resizable panels
+        main_layout = QHBoxLayout()
+        central_widget.setLayout(main_layout)
+        
+        # Left side: Grid and controls
+        left_widget = QWidget()
+        left_layout = QVBoxLayout()
+        left_widget.setLayout(left_layout)
+        
+        # Right side: Information panel
+        right_widget = QWidget()
+        right_widget.setMaximumWidth(350)
+        right_layout = QVBoxLayout()
+        right_widget.setLayout(right_layout)
+        
+        # === LEFT PANEL: Grid and Controls ===
+        
+        # Metrics display at top
+        metrics_layout = QHBoxLayout()
+        
+        # Left metrics column
+        left_metrics = QVBoxLayout()
+        self.steps_label = QLabel("Steps: 0")
+        self.cost_label = QLabel("Total Cost: 0.0")
+        self.turn_cost_label = QLabel("Turn Cost: 0.0")
+        self.dirty_label = QLabel("Dirty Cells: 0")
+        
+        left_metrics.addWidget(self.steps_label)
+        left_metrics.addWidget(self.cost_label)
+        left_metrics.addWidget(self.turn_cost_label)
+        left_metrics.addWidget(self.dirty_label)
+        
+        # Right metrics column
+        right_metrics = QVBoxLayout()
+        self.nodes_explored_label = QLabel("Nodes Explored: 0")
+        self.nodes_expanded_label = QLabel("Nodes Expanded: 0")
+        self.comp_time_label = QLabel("Comp Time: 0.000s")
+        self.algorithm_label = QLabel("Algorithm: None")
+        
+        right_metrics.addWidget(self.nodes_explored_label)
+        right_metrics.addWidget(self.nodes_expanded_label)
+        right_metrics.addWidget(self.comp_time_label)
+        right_metrics.addWidget(self.algorithm_label)
+        
+        metrics_layout.addLayout(left_metrics)
+        metrics_layout.addLayout(right_metrics)
+        metrics_layout.addStretch()
+        
+        left_layout.addLayout(metrics_layout)
+        
+        # Control panel
+        control_layout = QHBoxLayout()
+        
+        # Reset button
+        self.reset_button = QPushButton("Reset")
+        self.reset_button.clicked.connect(self.reset_simulation)
+        control_layout.addWidget(self.reset_button)
+        
+        # Next button
+        self.next_button = QPushButton("Next")
+        self.next_button.clicked.connect(self.next_step)
+        control_layout.addWidget(self.next_button)
+        
+        # Run button
+        self.run_button = QPushButton("Run")
+        self.run_button.clicked.connect(self.toggle_run)
+        control_layout.addWidget(self.run_button)
+        
+        control_layout.addStretch()
+        left_layout.addLayout(control_layout)
+        
+        # Search options
+        search_layout = QHBoxLayout()
+        
+        # Turn cost checkbox
+        self.turn_cost_checkbox = QCheckBox("Turn Cost (0.5 per 90° turn)")
+        self.turn_cost_checkbox.stateChanged.connect(self.toggle_turn_cost)
+        search_layout.addWidget(self.turn_cost_checkbox)
+        
+        # Search algorithm dropdown
+        search_layout.addWidget(QLabel("Search:"))
+        self.search_combo = QComboBox()
+        self.search_combo.addItems(["BFS", "A* Manhattan", "A* Euclidean", "A* Chebyshev"])
+        search_layout.addWidget(self.search_combo)
+        
+        search_layout.addStretch()
+        left_layout.addLayout(search_layout)
+        
+        # Grid display
+        self.grid_widget = GridWidget(self.rows, self.cols, self.cell_size, self.env)
+        left_layout.addWidget(self.grid_widget)
+        
+        # Legend (moved to bottom of left panel)
+        legend_layout = QHBoxLayout()
+        
+        def create_legend_item(color, text):
+            item_widget = QWidget()
+            item_layout = QHBoxLayout()
+            item_widget.setLayout(item_layout)
+            
+            color_label = QLabel()
+            color_label.setFixedSize(16, 16)
+            color_label.setStyleSheet(f"background-color: {color}; border: 1px solid black")
+            item_layout.addWidget(color_label)
+            
+            text_label = QLabel(text)
+            text_label.setStyleSheet("font-size: 10px;")
+            item_layout.addWidget(text_label)
+            item_layout.setContentsMargins(2, 0, 5, 0)
+            
+            return item_widget
+        
+        legend_layout.addWidget(create_legend_item("yellow", "Clean"))
+        legend_layout.addWidget(create_legend_item("red", "Dirty"))
+        legend_layout.addWidget(create_legend_item("blue", "Obstacle"))
+        legend_layout.addWidget(create_legend_item("green", "Explored"))
+        legend_layout.addWidget(create_legend_item("orange", "Path"))
+        legend_layout.addStretch()
+        
+        left_layout.addLayout(legend_layout)
+        
+        # === RIGHT PANEL: Information and Statistics ===
+        
+        # Algorithm Information
+        info_label = QLabel("Algorithm Information:")
+        info_label.setStyleSheet("font-weight: bold; font-size: 12px; margin-bottom: 5px;")
+        right_layout.addWidget(info_label)
+        
+        info_text = QTextEdit()
+        info_text.setMaximumHeight(120)
+        info_text.setReadOnly(True)
+        info_text.setHtml("""
+        <b>Search Algorithms:</b><br>
+        • <b>BFS</b>: Explores all directions equally, finds shortest path<br>
+        • <b>A* Manhattan</b>: Uses city-block distance heuristic<br>
+        • <b>A* Euclidean</b>: Uses straight-line distance heuristic<br>
+        • <b>A* Chebyshev</b>: Uses chessboard distance heuristic<br><br>
+        <b>Turn Cost</b>: When enabled, 90° turns cost +0.5
+        """)
+        right_layout.addWidget(info_text)
+        
+        # Performance Statistics
+        stats_label = QLabel("Algorithm Performance:")
+        stats_label.setStyleSheet("font-weight: bold; font-size: 12px; margin-top: 10px; margin-bottom: 5px;")
+        right_layout.addWidget(stats_label)
+        
+        self.stats_text = QTextEdit()
+        self.stats_text.setReadOnly(True)
+        self.stats_text.setStyleSheet("font-family: monospace; font-size: 10px;")
+        right_layout.addWidget(self.stats_text)
+        
+        # Current Run Analysis
+        analysis_label = QLabel("Current Run Analysis:")
+        analysis_label.setStyleSheet("font-weight: bold; font-size: 12px; margin-top: 10px; margin-bottom: 5px;")
+        right_layout.addWidget(analysis_label)
+        
+        self.analysis_text = QTextEdit()
+        self.analysis_text.setMaximumHeight(100)
+        self.analysis_text.setReadOnly(True)
+        self.analysis_text.setStyleSheet("font-family: monospace; font-size: 10px;")
+        right_layout.addWidget(self.analysis_text)
+        
+        # Add stretch to push everything to top
+        right_layout.addStretch()
+        
+        # Add both panels to main layout
+        main_layout.addWidget(left_widget)
+        main_layout.addWidget(right_widget)
+        
+        # Set left widget to expand, right widget fixed width
+        main_layout.setStretchFactor(left_widget, 1)
+        main_layout.setStretchFactor(right_widget, 0)
+        
+        self.update_stats_display()
+    
+    def update_stats_display(self):
+        stats_text = "<pre>"
+        for algo, stats in self.algorithm_stats.items():
+            if stats["runs"] > 0:
+                avg_nodes = stats["total_nodes"] / stats["runs"]
+                avg_time = stats["total_time"] / stats["runs"]
+                stats_text += f"{algo:<15} {stats['runs']:>3} runs\n"
+                stats_text += f"  Avg Nodes: {avg_nodes:>6.1f}\n"
+                stats_text += f"  Avg Time:  {avg_time:>7.4f}s\n"
+            else:
+                stats_text += f"{algo:<15} No runs yet\n"
+        stats_text += "</pre>"
+        
+        # Add Chebyshev vs Euclidean comparison to analysis
+        chebyshev_stats = self.algorithm_stats["A* Chebyshev"]
+        euclidean_stats = self.algorithm_stats["A* Euclidean"]
+        
+        analysis_text = "<pre>"
+        if chebyshev_stats["runs"] > 0 and euclidean_stats["runs"] > 0:
+            chebyshev_avg_nodes = chebyshev_stats["total_nodes"] / chebyshev_stats["runs"]
+            euclidean_avg_nodes = euclidean_stats["total_nodes"] / euclidean_stats["runs"]
+            chebyshev_avg_time = chebyshev_stats["total_time"] / chebyshev_stats["runs"]
+            euclidean_avg_time = euclidean_stats["total_time"] / euclidean_stats["runs"]
+            
+            if euclidean_avg_nodes > 0:
+                node_ratio = chebyshev_avg_nodes / euclidean_avg_nodes
+                analysis_text += f"Node Exploration:\n"
+                analysis_text += f"  Chebyshev explores {node_ratio:.1f}x\n"
+                analysis_text += f"  more nodes than Euclidean\n\n"
+            
+            if euclidean_avg_time > 0:
+                time_ratio = chebyshev_avg_time / euclidean_avg_time
+                analysis_text += f"Computation Time:\n"
+                analysis_text += f"  Chebyshev is {time_ratio:.1f}x\n"
+                analysis_text += f"  slower than Euclidean"
+        else:
+            analysis_text += "Run simulations to see\nalgorithm comparisons"
+        analysis_text += "</pre>"
+        
+        self.stats_text.setHtml(stats_text)
+        self.analysis_text.setHtml(analysis_text)
+    
+    def update_display(self):
+        self.steps_label.setText(f"Steps: {self.steps_taken}")
+        self.cost_label.setText(f"Total Cost: {self.total_cost:.2f}")
+        
+        # Calculate turn cost separately
+        turn_cost = max(0, self.total_cost - self.steps_taken)
+        self.turn_cost_label.setText(f"Turn Cost: {turn_cost:.2f}")
+        
+        self.dirty_label.setText(f"Dirty Cells: {self.env.get_dirty_count()}")
+        self.nodes_explored_label.setText(f"Nodes Explored: {len(self.explored_cells)}")
+        self.nodes_expanded_label.setText(f"Nodes Expanded: {self.total_nodes_expanded}")
+        self.comp_time_label.setText(f"Comp Time: {self.total_computation_time:.3f}s")
+        
+        current_algorithm = self.search_combo.currentText()
+        self.algorithm_label.setText(f"Algorithm: {current_algorithm}")
+        
+        self.grid_widget.update_path(self.current_path, self.current_direction)
+    
+    def reset_simulation(self):
+        self.env.reset()
+        self.current_path = []
+        self.explored_cells = set()
+        self.steps_taken = 0
+        self.total_cost = 0
+        self.current_direction = None
+        self.total_nodes_expanded = 0
+        self.total_computation_time = 0
+        self.is_running = False
+        self.timer.stop()
+        self.run_button.setText("Run")
+        self.update_display()
+    
+    def next_step(self):
+        if self.env.is_clean():
+            self.is_running = False
+            self.timer.stop()
+            self.run_button.setText("Run")
+            return
+        
+        # If we don't have a path, find one
+        if not self.current_path:
+            self.find_path()
+            # If still no path after searching, stop
+            if not self.current_path:
+                self.is_running = False
+                self.timer.stop()
+                self.run_button.setText("Run")
+                return
+        
+        # If we have a path, move along it
+        if self.current_path:
+            # Move to next position in path
+            next_pos = self.current_path.pop(0)
+            current_pos = self.env.vacuum_pos
+            
+            # Calculate movement cost with turn cost
+            move_cost = 1  # Base movement cost
+            
+            # Determine new direction based on movement
+            new_direction = Direction.from_movement(current_pos, next_pos)
+            
+            if self.turn_cost_checkbox.isChecked() and self.current_direction is not None:
+                # Add turn cost if direction changed
+                if self.current_direction != new_direction:
+                    turn_cost = 0.5  # 90° turn cost
+                    move_cost += turn_cost
+            
+            # Update direction
+            self.current_direction = new_direction
+            
+            # Update vacuum position
+            self.env.vacuum_pos = next_pos
+            self.steps_taken += 1
+            self.total_cost += move_cost
+            
+            # Clean the cell if it's dirty
+            if self.env.clean_cell(next_pos[0], next_pos[1]):
+                # If we cleaned a cell, we need to find a new path
+                self.current_path = []
+            
+            # Mark cell as explored
+            self.env.mark_explored(next_pos[0], next_pos[1])
+        
+        self.update_display()
+    
+    def find_path(self):
+        # Get selected search algorithm
+        search_type = self.search_combo.currentText()
+        
+        if search_type == "BFS":
+            algorithm = "bfs"
+            heuristic = "manhattan"
+        else:
+            algorithm = "a_star"
+            if search_type == "A* Manhattan":
+                heuristic = "manhattan"
+            elif search_type == "A* Euclidean":
+                heuristic = "euclidean"
+            else:  # A* Chebyshev
+                heuristic = "chebyshev"
+        
+        # Update search algorithm with current turn cost setting
+        self.search.turn_cost_enabled = self.turn_cost_checkbox.isChecked()
+        
+        # Find path to nearest dirty cell
+        path, explored, nodes_expanded, computation_time = self.search.find_path_to_nearest_dirty(
+            self.env.vacuum_pos, algorithm, heuristic)
+        
+        # Update performance metrics
+        self.total_nodes_expanded += nodes_expanded
+        self.total_computation_time += computation_time
+        
+        # Update algorithm statistics
+        self.algorithm_stats[search_type]["runs"] += 1
+        self.algorithm_stats[search_type]["total_nodes"] += nodes_expanded
+        self.algorithm_stats[search_type]["total_time"] += computation_time
+        
+        if path:
+            # Remove current position from path
+            self.current_path = path[1:]
+            self.explored_cells.update(explored)
+            
+            # Mark explored cells
+            for row, col in explored:
+                if (row, col) != self.env.vacuum_pos and self.env.grid[row][col] == CellType.CLEAN:
+                    self.env.grid[row][col] = CellType.EXPLORED
+        
+        self.update_stats_display()
+    
+    def toggle_run(self):
+        self.is_running = not self.is_running
+        
+        if self.is_running:
+            self.run_button.setText("Pause")
+            self.timer.start(500)  # 0.5 second interval for faster visualization
+        else:
+            self.run_button.setText("Run")
+            self.timer.stop()
+    
+    def toggle_turn_cost(self):
+        # When turn cost is toggled, we need to recalculate the path
+        if self.current_path:
+            self.current_path = []