Certamente!

Vou explicar o código em detalhes, destacando as bibliotecas

utilizadas, suas funções e como cada parte do código funciona.

cpp
Copy code
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
Nesta seção, incluímos as bibliotecas necessárias para o programa. <iostream> é
incluída para entrada e saída padrão, <vector> para usar vetores, <map> para usar o
mapa de adjacência e <algorithm> para auxiliar na remoção de elementos.

cpp
Copy code
using namespace std;
Essa declaração permite o uso direto de nomes da biblioteca padrão, como cout, cin
e vector, sem especificar o namespace em cada uso.

cpp
Copy code
struct Edge {
int vertex;
int weight;
};
Aqui, definimos uma estrutura Edge que representa uma aresta no grafo. Ela armazena
o vértice de destino (vertex) e o peso da aresta (weight).

cpp
Copy code
class Graph {
int numVertices;
map<int, vector<Edge>> adjacencyList;
vector<vector<int>> adjacencyMatrix;

public:
Graph(int vertices) : numVertices(vertices) {
adjacencyMatrix.resize(numVertices, vector<int>(numVertices, 0));
}
Em seguida, definimos a classe Graph, que representa o grafo em si. Ela contém as
variáveis numVertices (número de vértices), adjacencyList (mapa de adjacência) e
adjacencyMatrix (matriz de adjacência). O construtor da classe recebe o número de
vértices como parâmetro e inicializa a matriz de adjacência com um tamanho
numVertices x numVertices preenchido com zeros.

cpp
Copy code
void addEdge(int src, int dest, int weight) {
adjacencyMatrix[src][dest] = weight;
adjacencyMatrix[dest][src] = weight;
adjacencyList[src].push_back({dest, weight});
adjacencyList[dest].push_back({src, weight});
}
A função addEdge adiciona uma aresta ao grafo. Ela recebe o vértice de origem
(src), o vértice de destino (dest) e o peso da aresta (weight). A função atualiza a
matriz de adjacência, atribuindo o peso às posições correspondentes, e adiciona a
aresta aos vetores da lista de adjacência para ambos os vértices.

cpp
Copy code
void removeVertex(int vertex) {
adjacencyList.erase(vertex);
for (auto& entry : adjacencyList) {
auto& edges = entry.second;
edges.erase(remove_if(edges.begin(), edges.end(),
[vertex](const Edge& edge) {
return edge.vertex == vertex;
}),
edges.end());
}
adjacencyMatrix[vertex].assign(numVertices, 0);
for (int i = 0; i < numVertices; i++) {
adjacencyMatrix[i][vertex] = 0;
}
}
A função removeVertex remove um vértice do grafo e todas as arestas associadas a
ele. Ela remove a entrada correspondente ao vértice na lista de adjacência. Em
seguida, percorre todos os vértices restantes no mapa de adjacência e remove as
arestas que têm o vértice removido como destino.

Também atualiza a linha e a coluna correspondentes na matriz de adjacência para o

vértice removido, atribuindo zeros.

cpp
Copy code
void displayAdjacencyMatrix() {
cout << "Adjacency Matrix:" << endl;
for (int i = 0; i < numVertices; i++) {
for (int j = 0; j < numVertices; j++) {
cout << adjacencyMatrix[i][j] << " ";
}
cout << endl;
}
}
A função displayAdjacencyMatrix exibe a matriz de adjacência do grafo. Ela percorre
a matriz e imprime os elementos correspondentes.

cpp
Copy code
void displayAdjacencyList() {
cout << "Adjacency List:" << endl;
for (const auto& entry : adjacencyList) {
int vertex = entry.first;
const vector<Edge>& edges = entry.second;
cout << "Vertex " << vertex << ": ";
for (const Edge& edge : edges) {
cout << "(" << edge.vertex << ", " << edge.weight << ") ";
}
cout << endl;
}
}
A função displayAdjacencyList exibe a lista de adjacência do grafo. Ela percorre o
mapa de adjacência e imprime cada vértice e suas arestas correspondentes.

cpp
Copy code
bool DFS(int src, int dest, vector<int>& path) {
vector<bool> visited(numVertices, false);
 path.clear();
path.push_back(src);
visited[src] = true;

if (src == dest) {
return true;
}

for (const Edge& edge : adjacencyList[src]) {

if (!visited[edge.vertex]) {
bool found = DFS(edge.vertex, dest, path);
if (found) {
return true;
}
}
}

path.pop_back();
return false;
}
A função DFS implementa a busca em profundidade (Depth-First Search) no grafo. Ela
recebe o vértice de origem (src), o vértice de destino (dest) e uma referência para
o vetor path que armazena o caminho percorrido.

A função utiliza uma abordagem recursiva para percorrer o grafo. Ela mantém um
vetor visited para marcar os vértices visitados e adiciona o vértice atual ao
caminho path.

Se o vértice atual for igual ao destino, significa que encontramos um caminho e

retornamos true. Caso contrário, percorremos todas as arestas do vértice atual na
lista de adjacência e fazemos uma chamada recursiva para o vértice adjacente, desde
que ele não tenha sido visitado. Se algum dos vértices adjacentes retornar true,
significa que encontramos um caminho até o destino e retornamos true.

Se nenhum caminho for encontrado a partir do vértice atual, removemos o vértice do

caminho e retornamos false.

cpp
Copy code
void searchVertex(int src, int dest) {
vector<int> path;
bool found = DFS(src, dest, path);
cout << "Search Vertex Result: ";
if (found) {
cout << "Vertex " << dest << " found with path: ";
for (int vertex : path) {
cout << vertex << " ";
}
} else {
cout << "Vertex " << dest << " not found.";
}
cout << endl;
}
A função searchVertex realiza uma busca por um vértice a partir de outro vértice.
Ela chama a função DFS para realizar a busca e, em seguida, imprime o resultado na
saída padrão.

cpp
Copy code
void findPath(int src, int dest) {
vector<int> path;
bool found = DFS(src, dest, path);
cout << "Find Path Result: ";
if (found) {
cout << "Path from Vertex " << src << " to Vertex " << dest << ": ";
for (int vertex : path) {
cout << vertex << " ";
}
} else {
cout << "No path found from Vertex " << src << " to Vertex " << dest;
}
cout << endl;
}
A função findPath encontra um caminho entre dois vértices e imprime o caminho
encontrado na saída padrão. Ela utiliza a função DFS para encontrar o caminho.

cpp
Copy code
void findShortestPath(int src, int dest) {
vector<int> path;
bool found = DFS(src, dest, path);
cout << "Find Shortest Path Result: ";
if (found) {
cout << "Shortest path from Vertex " << src << " to Vertex " << dest << ":
";
for (int vertex : path) {
cout << vertex << " ";
}
int totalWeight = 0;
for (int i = 0; i < path.size() - 1; i++) {
int currVertex = path[i];
int nextVertex = path[i + 1];
totalWeight += adjacencyMatrix[currVertex][nextVertex];
}
cout << "with total weight: " << totalWeight;
} else {
cout << "No path found from Vertex " << src << " to Vertex " << dest;
}
cout << endl;
}
A função findShortestPath encontra o caminho mais curto entre dois vértices e
imprime o caminho e o peso total na saída padrão. Ela utiliza a função DFS para
encontrar o caminho e calcula o peso total somando os pesos das arestas
correspondentes na matriz de adjacência.

cpp
Copy code
void findMinimumEdges(int src, int dest) {
vector<int> path;
bool found = DFS(src, dest, path);
cout << "Find Minimum Edges Result: ";
if (found) {
int numEdges = path.size() - 1;
cout << "Minimum number of edges from Vertex " << src << " to Vertex " <<
dest << ": " << numEdges;
} else {
cout << "No path found from Vertex " << src << " to Vertex " << dest;
}
 cout << endl;
}
A função findMinimumEdges encontra o número mínimo de arestas necessárias para
alcançar um vértice a partir de outro vértice. Ela utiliza a função DFS para
encontrar o caminho e conta o número de arestas no caminho encontrado.

cpp
Copy code
int main() {
int numVertices;
cout << "Enter the number of vertices: ";
cin >> numVertices;

Graph graph(numVertices);

int choice;
while (true) {
cout << "---------------------------" << endl;
cout << "1. Add Edge" << endl;
cout << "2. Remove Vertex" << endl;
cout << "3. Display Adjacency Matrix" << endl;
cout << "4. Display Adjacency List" << endl;
cout << "5. Search Vertex" << endl;
cout << "6. Find Path" << endl;
cout << "7. Find Shortest Path" << endl;
cout << "8. Find Minimum Edges" << endl;
cout << "9. Exit" << endl;
cout << "---------------------------" << endl;
cout << "Enter your choice: ";
cin >> choice;

int src, dest, weight;

switch (choice) {
case 1:
cout << "Enter source vertex: ";
cin >> src;
cout << "Enter destination vertex: ";
cin >> dest;
cout << "Enter weight: ";
cin >> weight;
graph.addEdge(src, dest, weight);
graph.displayAdjacencyMatrix();
graph.displayAdjacencyList();
break;
case 2:
cout << "Enter the vertex to remove: ";
cin >> dest;
graph.removeVertex(dest);
graph.displayAdjacencyMatrix();
graph.displayAdjacencyList();
break;
case 3:
graph.displayAdjacencyMatrix();
break;
case 4:
graph.displayAdjacencyList();
break;
case 5:
cout << "Enter source vertex: ";
 cin >> src;
cout << "Enter destination vertex: ";
cin >> dest;
graph.searchVertex(src, dest);
break;
case 6:
cout << "Enter source vertex: ";
cin >> src;
cout << "Enter destination vertex: ";
cin >> dest;
graph.findPath(src, dest);
break;
case 7:
cout << "Enter source vertex: ";
cin >> src;
cout << "Enter destination vertex: ";
cin >> dest;
graph.findShortestPath(src, dest);
break;
case 8:
cout << "Enter source vertex: ";
cin >> src;
cout << "Enter destination vertex: ";
cin >> dest;
graph.findMinimumEdges(src, dest);
break;
case 9:
return 0;
default:
cout << "Invalid choice. Please try again." << endl;
}
}

return 0;
}
A função main é o ponto de entrada do programa. Ela contém um loop while (true) que
exibe um menu de opções e realiza as operações de acordo com a escolha do usuário.

No menu, o usuário pode adicionar uma aresta (1), remover um vértice (2), exibir a
matriz de adjacência (3), exibir a lista de adjacência (4), realizar uma busca por
vértice (5), encontrar um caminho (6), encontrar o caminho mais curto (7),
encontrar o número mínimo de arestas (8) ou sair do programa (9).

Cada opção chama a função correspondente da classe Graph e exibe a matriz de

adjacência e a lista de adjacência atualizadas.

Espero que essa explicação detalhada do código tenha ajudado a entender o

funcionamento do programa!