Графовый поиск на Go

Входные параметры:
1. Тип алгоритма: [Алгоритм]
2. Структура графа: [Структура]
3. Начальная вершина: [Старт]
4. Целевая вершина (опционально): [Цель]
5. Требуемый вывод: [Вывод]

Ты эксперт в Go и теории графов. Твоя задача - реализовать алгоритм графового поиска, строго следуя параметрам.

Шаги:

1. Анализ и планирование:
   - Определи тип алгоритма: [Алгоритм] (BFS, DFS, Dijkstra, A* и т.д.).
   - Проанализируй структуру графа: [Структура] (список смежности, матрица смежности, взвешенный/невзвешенный, ориентированный/неориентированный).
   - Учни начальную вершину [Старт] и, если применимо, целевую [Цель].
   - Определи, что должен вернуть код: [Вывод] (кратчайший путь, порядок обхода, дерево поиска, стоимость пути).

2. Реализация:
   - Создай структуру данных для представления графа на основе [Структура].
   - Реализуй точный алгоритм [Алгоритм] с учетом специфики графа.
   - Используй стандартные контейнеры Go (слайсы, карты, очереди через каналы или пакет `container`).
   - Включи необходимые проверки: существование вершин [Старт] и [Цель], отсутствие циклов (если критично для алгоритма).
   - Обеспечь модульность. Раздели код на функции: построение графа, алгоритм поиска, вывод результата.

3. Вывод и обработка результатов:
   - Результат должен соответствовать параметру [Вывод].
   - Для пути выведи последовательность вершин или ребер.
   - Для порядка обхода выведи список вершин в порядке посещения.
   - Для стоимости выведи числовое значение и путь, если применимо.

4. Критерии успеха:
   - Код компилируется без ошибок.
   - Алгоритм корректен для заданного типа графа.
   - Результат точен и соответствует параметру [Вывод].
   - Обработаны крайние случаи: пустой граф, старт равен цели, путь отсутствует.
   - Код читаем, содержит комментарии для ключевых блоков.

5. Типичные ошибки (Избегай их):
   - Путаница между BFS (очередь) и DFS (стек).
   - Игнорирование весов ребер в взвешенных графах для алгоритмов вроде Dijkstra.
   - Бесконечные циклы из-за непомеченных посещенных вершин.
   - Некорректная работа с индексами вершин.
   - Отсутствие проверки на существование вершин.

Предоставь полный код на Go, готовый к компиляции и выполнению.

Input Parameters:
1. Algorithm Type: [Algorithm]
2. Graph Structure: [Structure]
3. Starting Vertex: [Start]
4. Target Vertex (optional): [Target]
5. Required Output: [Output]

You are an expert in Go and graph theory. Your task is to implement a graph search algorithm, strictly following the parameters.

Steps:

1. Analysis and Planning:
   - Identify the algorithm type: [Algorithm] (BFS, DFS, Dijkstra, A*, etc.).
   - Analyze the graph structure: [Structure] (adjacency list, adjacency matrix, weighted/unweighted, directed/undirected).
   - Consider the starting vertex [Start] and, if applicable, the target [Target].
   - Determine what the code should return: [Output] (shortest path, traversal order, search tree, path cost).

2. Implementation:
   - Create a data structure to represent the graph based on [Structure].
   - Implement the exact algorithm [Algorithm] considering the graph's specifics.
   - Use standard Go containers (slices, maps, queues via channels or the `container` package).
   - Include necessary checks: existence of vertices [Start] and [Target], absence of cycles (if critical for the algorithm).
   - Ensure modularity. Split code into functions: graph construction, search algorithm, result output.

3. Output and Result Processing:
   - The result must match the [Output] parameter.
   - For a path, output the sequence of vertices or edges.
   - For traversal order, output the list of vertices in the order visited.
   - For cost, output the numerical value and the path, if applicable.

4. Success Criteria:
   - Code compiles without errors.
   - The algorithm is correct for the given graph type.
   - The result is accurate and matches the [Output] parameter.
   - Edge cases are handled: empty graph, start equals target, no path exists.
   - Code is readable and contains comments for key blocks.

5. Common Mistakes (Avoid them):
   - Confusion between BFS (queue) and DFS (stack).
   - Ignoring edge weights in weighted graphs for algorithms like Dijkstra.
   - Infinite loops due to unmarked visited vertices.
   - Incorrect handling of vertex indices.
   - Lack of checks for vertex existence.

Provide the complete Go code ready for compilation and execution.