Коллок

Чтобы проверить, является ли граф минимальным (каждое ребро критическое), необходимо убедиться, что удаление любого ребра увеличивает количество компонент связности графа. Другими словами, каждое ребро должно быть мостом.

Вот как можно реализовать такую функцию на Java, используя предоставленный API для графа:

```java
import java.util.*;

public class GraphCheck {

    public static boolean isGraphMinimal(Graph graph) {
        for (Edge edge : graph.getEdges()) {
            // Создаём копию графа без текущего ребра
            Graph modifiedGraph = removeEdge(graph, edge);
            if (isConnected(modifiedGraph)) {
                return false;
            }
        }
        return true;
    }

    private static Graph removeEdge(Graph graph, Edge edgeToRemove) {
        List<Edge> newEdges = new ArrayList<>(graph.getEdges());
        newEdges.removeIf(edge -> edge.getFromV().equals(edgeToRemove.getFromV()) &&
                                  edge.getToV().equals(edgeToRemove.getToV()));

        return Graph.builder()
            .setDirectType(graph.getDirectType())
            .setVertexCount(graph.getVertexCount())
            .setEdgeCount(newEdges.size())
            .setVertices(graph.getVertices())
            .setEdges(newEdges)
            .build();
    }

    private static boolean isConnected(Graph graph) {
        if (graph.getVertexCount() == 0) {
            return true;
        }

        Set<UUID> visited = new HashSet<>();
        Queue<UUID> queue = new LinkedList<>();
        UUID startVertex = graph.getVertices().keySet().iterator().next();

        queue.add(startVertex);
        visited.add(startVertex);

        while (!queue.isEmpty()) {
            UUID vertex = queue.poll();
            for (UUID neighbor : getNeighbors(graph, vertex)) {
                if (!visited.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.add(neighbor);
                }
            }
        }

        return visited.size() == graph.getVertexCount();
    }

    private static List<UUID> getNeighbors(Graph graph, UUID vertexId) {
        List<UUID> neighbors = new ArrayList<>();
        for (Edge edge : graph.getEdges()) {
            if (edge.getFromV().equals(vertexId)) {
                neighbors.add(edge.getToV());
            }
            if (graph.getDirectType() == GraphType.UNDIRECTED && edge.getToV().equals(vertexId)) {
                neighbors.add(edge.getFromV());
            }
        }
        return neighbors;
    }

    public static void main(String[] args) {
        // Пример создания графа
        Vertex v0 = Vertex.builder().setId(UUID.randomUUID()).build();
        Vertex v1 = Vertex.builder().setId(UUID.randomUUID()).build();
        Vertex v2 = Vertex.builder().setId(UUID.randomUUID()).build();
        Vertex v3 = Vertex.builder().setId(UUID.randomUUID()).build();

        Edge e0 = Edge.builder().setFromV(v0.getId()).setToV(v1.getId()).build();
        Edge e1 = Edge.builder().setFromV(v0.getId()).setToV(v2.getId()).build();
        Edge e2 = Edge.builder().setFromV(v1.getId()).setToV(v2.getId()).build();
        Edge e3 = Edge.builder().setFromV(v2.getId()).setToV(v3.getId()).build();

        Map<UUID, Vertex> vertices = new HashMap<>();
        vertices.put(v0.getId(), v0);
        vertices.put(v1.getId(), v1);
        vertices.put(v2.getId(), v2);
        vertices.put(v3.getId(), v3);

        List<Edge> edges = new ArrayList<>();
        edges.add(e0);
        edges.add(e1);
        edges.add(e2);
        edges.add(e3);

        Graph graph = Graph.builder()
            .setDirectType(GraphType.UNDIRECTED)  // Или GraphType.DIRECTED
            .setVertexCount(vertices.size())
            .setEdgeCount(edges.size())
            .setVertices(vertices)
            .setEdges(edges)
            .build();

        // Проверка, является ли граф минимальным
        boolean isMinimal = isGraphMinimal(graph);
        System.out.println("The graph is minimal: " + isMinimal);
    }
}
```

### Объяснение

1. **Метод `isGraphMinimal`**:
    - Проверяет каждое ребро графа.
    - Удаляет ребро и проверяет, остался ли граф связным. Если граф остаётся связным после удаления хотя бы одного ребра, граф не является минимальным.

2. **Метод `removeEdge`**:
    - Создаёт копию графа без указанного ребра.

3. **Метод `isConnected`**:
    - Проверяет, является ли граф связным, используя поиск в ширину (BFS).

4. **Метод `getNeighbors`**:
    - Возвращает список соседей для заданной вершины.

5. **Пример использования**:
    - В методе `main` создаётся пример графа с вершинами и рёбрами, затем вызывается метод `isGraphMinimal`, и результат выводится на экран.

Этот код проверяет, является ли граф минимальным, используя предоставленный API.