If path is None:

path = [current_node]

if shortest is None or len(path) < len(shortest):

if current_node == goal:

shortest = path

for node in range(len(matrix[current_node])):

if matrix[current_node][node] == 1 and node not in path:

new_path = dfs_shortest(matrix, node, goal, path + [node], shortest)

If new_path:

shortest = new_path if not shortest or len(new_path) < len(shortest) else shortest

return shortest

def measure_dfs_time_fixed(matrix, repeats=100):

matrix_size = len(matrix)

start_node = 0

goal_node = matrix_size - 1

times = []

for _ in range(repeats):

start_time = time.time()

dfs_shortest(matrix, start_node, goal_node)

end_time = time.time()

times.append(end_time - start_time)

return np.mean(times)

def evaluate_performance_for_fixed_M_sizes(M_sizes):

performance_results = []

for M in M_sizes:

matrix = create_hexagonal_grid_fixed(M)

avg_time = measure_dfs_time_fixed(matrix)

performance_results.append(avg_time)

return performance_results

M_sizes_fixed = [3, 4, 5, 6]

performance_results_fixed = evaluate_performance_for_fixed_M_sizes(M_sizes_fixed)

# Вывод результатов с шестью знаками после запятой

for M, time in zip(M_sizes_fixed, performance_results_fixed):

print(f'M = {M}, Time = {time:.6f} seconds')

# График

plt.figure(figsize=(10, 5))

plt.plot([M * M for M in M_sizes_fixed], [round(t, 6) for t in performance_results_fixed], marker='o', color='red')

plt.title('Зависимость времени выполнения алгоритма DFS от количества узлов')

plt.xlabel('Количество узлов (M*M)')

plt.ylabel('Среднее время выполнения ')

plt.grid(True)

plt.show()