Exercício resolvidos durante o Curso de Grafos e Algoritmos (como aluno de Engenharia da Computação) do Departamento de Computação da Universidade Federal de Sergipe.

1. JULIO CESAR DE ARAUJO MENEZES
PROVA ON-LINE (1ª AVALIAÇÃO - EXERCÍCIO)
GRAFOS E ALGORÍTIMOS
ALGORITMO:
Dijkstra e Bellman-Ford para encontrar caminhos mínimos,
e os de Kruskal e Prim para encontrar árvores geradoras
mínimas.
Orientador: Prof. Dr. Jânio Coutinho Canuto
São Cristóvão/SE
2020
UNIVERSIDADE FEDERAL DE SERGIPE
CENTRO DE CIÊNCIAS EXATAS E TECNOLOGICAS
DEPARTAMENTO DE ENGENHARIA DA COMPUTAÇÃO

2. Serviço Público Federal
Universidade Federal de Sergipe
Centro de Ciências Exatas e Tecnologia
Departamento de Ciência da Computação
Avaliação de Grafos - 2019/2
Professor: Jânio Coutinho Canuto
Na sala de aula vimos os algoritmos de Dijkstra e Bellman-Ford para encontrar caminhos mínimos,
e os de Kruskal e Prim para encontrar árvores geradoras mínimas. Para cada um dos quatro algoritmos
faça:
1) Implemente os algoritmos na linguagem de programação de sua preferência. Não precisa de
executável nem de interface com usuário.
ˆ Os algoritmos de árvore mínima devem ser funções que recebem como argumento o nome de
um arquivo contendo a matriz de adjacência de um dígrafo simples ponderado. O retorno
deve ser a matriz de adjacência da árvore.
ˆ Os algoritmos de caminho mínimo, além do nome do arquivo, também devem receber um
número indicando o vértice de origem como entrada. O retorno deve ser uma lista com a
distância do vértice de origem para os demais vértices.
2) Expresse o número aproximado de operações (somas, subtrações, divisões, multiplicações, com-
parações) necessárias para obter a resposta na sua implementação, em função do número de
vértices e/ou arestas do grafo de entrada.
Os arquivos de testes usados conterão uma lista de valores separados por vírgula. Cada linha do arquivo
de texto corresponde a uma linha da matriz de adjacência. Valores iguais a 0 indicam a ausência de
aresta, valores diferentes de 0 indicam o peso da aresta. Assuma que os vértices são numerados de
1 a N, onde N é o número de linhas da matriz de adjacência, para as entradas e saídas das funções
implementadas.

3. 1 //+++++++++++++++++++++++++++++++++++++++++++++++//
2 //ALUNO: JULIO CESAR DE ARAUJO MENEZES//
3 //PROFESSOR ORIENTADOR: DR. JÂNIO COUTINHO CANUTO//
4 //+++++++++++++++++++++++++++++++++++++++++++++++//
5
6 import java.io.BufferedReader;
7 import java.io.FileNotFoundException;
8 import java.io.FileReader;
9 import java.io.IOException;
10
11 public class Djisktra {
12 int qtd_vert;
13
14 int menor_dist(int dist[], Boolean cam_mais_leve[]) {
15 int min = Integer.MAX_VALUE;
16 int min_index = -1;
17
18 for (int v = 0; v < qtd_vert; v++) // ++++++++ v iterações ++++++++++++++
19 if (cam_mais_leve[v] == false && dist[v] <= min) {
20 min = dist[v];
21 min_index = v;
22 }
23
24 return min_index;
25 }
26 // ++++++++++ v iterações +++++++
27 void imprimirSaida(int dist[], int origem) {
28 System.out.println("V�rtice ttDistancia da origem " +
String.valueOf(origem));
29 for (int i = 0; i < qtd_vert; i++)
30 System.out.println(i + " ttt " + dist[i]);
31 }
32
33 void dijkstra(int grafo[][], int origem) {
34 int dist[] = new int[qtd_vert];
35
36 Boolean cam_mais_leve[] = new Boolean[qtd_vert];
37
38 //+++++++++++++++ inicializa as distancias ++++++++++++++++
39 for (int i = 0; i < qtd_vert; i++) { // v iterações
40 dist[i] = Integer.MAX_VALUE;
41 cam_mais_leve[i] = false;
42 }
43
44 // +++++++++++++++++++distancia da origem para ela mesma+++++++++++++++++++
45 dist[origem] = 0;
46
47 // +++++++++++++++ v(v+v) iterações ++++++++++++++++
48 for (int i = 0; i < qtd_vert - 1; i++) {
49 int u = menor_dist(dist, cam_mais_leve);
50 cam_mais_leve[u] = true;
51 for (int v = 0; v < qtd_vert; v++) {
52 if (!cam_mais_leve[v] && grafo[u][v] != 0 && dist[u] !=
Integer.MAX_VALUE
53 && dist[u] + grafo[u][v] < dist[v]) {
54 dist[v] = dist[u] + grafo[u][v];
55 }
56 }
57 }
58 imprimirSaida(dist, origem);
59 }
60
61 private static void principal(String caminho_arquivo, int origem) throws
FileNotFoundException, IOException {
62 BufferedReader br = new BufferedReader(new FileReader(caminho_arquivo));
63 int qtd_vert = 0;
64 while (br.ready()) { // +++++++++++++ quantidade de vertices ++
65 String linha = br.readLine();
66 linha = linha.replace("n", "");
67 String lin_vet[] = linha.split(",");
68 qtd_vert = lin_vet.length;
69 break;
70 }

4. 71 br = new BufferedReader(new FileReader(caminho_arquivo));
72 int grafo[][] = new int[qtd_vert][qtd_vert];
73 int linha_corr = 0;
74 while (br.ready()) {
75 String linha = br.readLine();
76 linha = linha.replace("n", "");
77 String lin_vet[] = linha.split(",");
78 for (int i = 0; i < lin_vet.length; i++) {
79 grafo[linha_corr][i] = Integer.parseInt(lin_vet[i]);
80 }
81 linha_corr++;
82 }
83 Djisktra djk = new Djisktra();
84 djk.qtd_vert = qtd_vert;
85 djk.dijkstra(grafo, origem);
86 br.close();
87 }
88
89 public static void main(String[] args) throws IOException {
90
91 String caminho_arquivo = ""; //+++++++++++++ preecnher caminho do arquivo
++++++++
92 int origem = 0; // +++++++++++++++++++++++++ origem do vertice ++++++++++
93 principal(caminho_arquivo, origem);
94 }
95
96
97 }
98

5. 1 //+++++++++++++++++++++++++++++++++++++++++++++++//
2 //ALUNO: JULIO CESAR DE ARAUJO MENEZES//
3 //PROFESSOR ORIENTADOR: DR. JÂNIO COUTINHO CANUTO//
4 //+++++++++++++++++++++++++++++++++++++++++++++++//
5
6 import java.io.BufferedReader;
7 import java.io.FileNotFoundException;
8 import java.io.FileReader;
9 import java.io.IOException;
10
11 public class Bford {
12
13 static void bFord(int gf[][], int qtd_vert, int qt_a, int origem) {
14
15 int[] d = new int[qtd_vert];
16 for (int i = 0; i < qtd_vert; i++) // +++++v iterações+++
17 d[i] = Integer.MAX_VALUE;
18
19
20 d[origem] = 0;
21
22 //+++++++++++relaxamento de arestas+++++++++++
23 for (int i = 0; i < qtd_vert - 1; i++) { //+++++v*a iterações++++
24
25 for (int j = 0; j < qt_a; j++) {
26 if (d[gf[j][0]] + gf[j][2] < d[gf[j][1]])
27 d[gf[j][1]] = d[gf[j][0]] + gf[j][2];
28 }
29 }
30
31 //+++++++existe ciclos de pesos negativos++++++++
32 for (int i = 0; i < qt_a; i++) { // +++++++aresta iterações
33 int x = gf[i][0];
34 int y = gf[i][1];
35 int peso = gf[i][2];
36 if (d[x] != Integer.MAX_VALUE && d[x] + peso < d[y])
37 System.out.println("O gf possui algum ciclo de peso negativo");
38 }
39
40 System.out.println("Vertice t dancia da origem " + String.valueOf(origem));
41 for (int i = 0; i < qtd_vert; i++) // +++++++vertice iterações
42 System.out.println(i + "ttt" + d[i]);
43 }
44
45 private static void principal(String caminho_arquivo, int origem) throws
FileNotFoundException, IOException {
46 BufferedReader br = new BufferedReader(new FileReader(caminho_arquivo));
47 int qtd_vert = 0;
48 while (br.ready()) { // +++++++++qtd de vertices
49 String linha = br.readLine();
50 linha = linha.replace("n", "");
51 String lin_vet[] = linha.split(",");
52 qtd_vert = lin_vet.length;
53 break;
54 }
55 br = new BufferedReader(new FileReader(caminho_arquivo));
56
57
58 int qt_a = 0;
59 // ++++++++++++++cont as arestas
60 while (br.ready()) {
61 String linha = br.readLine();
62 linha = linha.replace("n", "");
63 String lin_vet[] = linha.split(",");
64 for (int i = 0; i < lin_vet.length; i++) {
65 if(!lin_vet[i].equalsIgnoreCase("0")) {
66 qt_a++;
67 }
68 }
69
70 }
71 int l_corr = 0;
72 int ar_aux= 0;

6. 73 int gf[][] = new int[qt_a][3];
74 br = new BufferedReader(new FileReader(caminho_arquivo));
75 while (br.ready()) {
76 String linha = br.readLine();
77 linha = linha.replace("n", "");
78 String lin_vet[] = linha.split(",");
79 for (int i = 0; i < lin_vet.length; i++) {
80 if(!lin_vet[i].equalsIgnoreCase("0")) {
81 gf[ar_aux][0] = l_corr;
82 gf[ar_aux][1] = i;
83 gf[ar_aux][2] = Integer.parseInt(lin_vet[i]);
84 aresta_aux ++;
85 }
86 }
87
88 l_corr++;
89 }
90
91 bFord(gf, qtd_vert, qt_a, origem);
92 }
93
94 public static void main(String[] args) throws FileNotFoundException, IOException {
95 String caminho_arquivo = "";
96 int origem = 0;
97 principal(caminho_arquivo, origem);
98 }
99 }
100

7. 1 //+++++++++++++++++++++++++++++++++++++++++++++++//
2 //ALUNO: JULIO CESAR DE ARAUJO MENEZES//
3 //PROFESSOR ORIENTADOR: DR. JÂNIO COUTINHO CANUTO//
4 //+++++++++++++++++++++++++++++++++++++++++++++++//
5
6
7 import java.io.BufferedReader;
8 import java.io.FileReader;
9 import java.io.IOException;
10 import java.util.ArrayList;
11 import java.util.Comparator;
12 import java.util.PriorityQueue;
13
14 public class Kruska {
15 static class Ares {
16 int vert1;
17 int vert2;
18 int peso;
19
20 public ares(int vert1, int vert2, int peso) {
21 this.vert1 = vert1;
22 this.vert2 = vert2;
23 this.peso = peso;
24 }
25 }
26
27 static class Grafo {
28 int vert;
29 ArrayList<Ares> lista_ares = new ArrayList<>();
30
31 Grafo(int vert) {
32 this.vert = vert;
33 }
34
35 public void adicionar_ares(int vert1, int vert2, int peso) {
36 Ares are = new Ares(vert1, vert2, peso);
37 lista_arest.add(are);
38 }
39
40 public void kruska(){
41 PriorityQueue<Ares> pq = new PriorityQueue<>(lista_ares.size(),
Comparator.comparingInt(o -> o.peso));
42
43 //++Adiciona arestas na fila e Ordena com o peso ++
44 for (int i = 0; i <lista_arestas.size() ; i++) { //+++++++++ are
iterações+++++++
45 pq.add(lista_ares.get(i));
46 }
47
48 int [] pai = new int[vert];
49
50 makeSet(pai); // +++++ vert iterações +++++++
51
52 ArrayList<Ares> arvore_geradora = new ArrayList<>();
53
54 int index = 0;
55 while(index<vert-1){ // ++++ vert iterações vert(vert+veret+2vert+are) +++
56 Ares ares = pq.remove();
57 int conjuntoX = find(pai, ares.vert1);// +++ vert iterações ++++
58 int conjuntoY = find(pai, ares.vert2);// ++++vert iterações+++++
59
60 if(conjuntoX!=conjuntoY){
61 arvore_geradora.add(ares);
62 index++;
63 union(pai,conjuntoX,conjuntoY); // +++ vert+vert iterações +++++
64 }
65 }
66 imprimirGrafo(arvore_geradora); // ++++++++ are iterações ++++++++
67 }
68
69 public void makeSet(int [] pai){
70 for (int i = 0; i <vert ; i++) { // +++++++ vert iterações +++++
71 pai[i] = i;

8. 72 }
73 }
74
75 public int find(int [] pai, int vertice){ // ++++ vert iterações ++++
76 if(pai[vertice]!=vertice)
77 return find(pai, pai[vertice]);;
78 return vertice;
79 }
80
81 public void union(int [] pai, int x, int y){ // +++ vert+vert iterações ++++++
82 int pai_de_x = find(pai, x);
83 int pai_de_y = find(pai, y);
84 pai[pai_de_y] = pai_de_x;
85 }
86
87 public void imprimirGrafo(ArrayList<Ares> ares){ // ++++ are iterações ++++
88 System.out.println("Arvore geradora minima: ");
89 for (int i = 0; i <ares.size() ; i++) {
90 Ares ares = ares.get(i);
91 System.out.println("Aresta:" + ((i+1)) + " vert1: " + ares.vert1 + "
vert2: " + ares.vert2 + " peso: " + ares.peso);
92 }
93 }
94 }
95
96 public static void principal(String caminho_arquivo) throws IOException{
97 Grafo grafo = null;
98
99 boolean grafo_criado = false;
100
101 BufferedReader br = new BufferedReader(new FileReader(caminho_arquivo));
102
103 int linha_corrente = 0;
104
105 while(br.ready()) {
106
107
108 String linha = br.readLine();
109 linha = linha.replace("n", "");
110 String lin_vet[] = linha.split(",");
111
112 if(!grafo_criado) {
113 grafo = new Grafo(lin_vet.length);
114 grafo_criado = true;
115 }
116 for(int i = 0; i < lin_vet.length; i++) {
117 if(!lin_vet[i].equalsIgnoreCase("0")) {
118 grafo.adicionar_aresta(linha_corrente, i,
Integer.parseInt(lin_vet[i]));
119 }
120 }
121 linha_corrente++;
122 }
123 grafo.kruska();
124 br.close();
125 }
126
127 public static void main(String[] args) throws IOException {
128 String caminho_arquivo = "";
129 principal(caminho_arquivo);
130 }
131 }
132

9. 1 //+++++++++++++++++++++++++++++++++++++++++++++++//
2 //ALUNO: JULIO CESAR DE ARAUJO MENEZES//
3 //PROFESSOR ORIENTADOR: DR. JÂNIO COUTINHO CANUTO//
4 //+++++++++++++++++++++++++++++++++++++++++++++++//
5
6
7 import java.io.BufferedReader;
8 import java.io.FileReader;
9 import java.io.IOException;
10
11 public class Prim {
12
13 static boolean isAreVal(int u, int v, boolean[] arv_g) {
14 if (u == v) {
15 return false;
16 }
17 if (arv_g[u] == false && arv_g[v] == false) {
18 return false;
19 } else if (arv_g[u] == true && arv_g[v] == true) {
20 return false;
21 }
22 return true;
23 }
24
25 static void prim(int grafo[][], int q_vert) {
26 boolean[] arv_g = new boolean[q_vert];
27
28 arv_g[0] = true;
29
30 int contador_arestas = 0, minP = 0;
31 // +++ vert iterações +++
32 while (contador_arestas < q_vert - 1) {
33
34 int min = Integer.MAX_VALUE, a = -1, b = -1;
35 // +++ vert*vert iterações +++
36 for (int i = 0; i < q_vert; i++) {
37 for (int j = 0; j < q_vert; j++) {
38 if (grafo[i][j] < min) {
39 if (isAreVal(i, j, arv_g)) {
40 min = grafo[i][j];
41 a = i;
42 b = j;
43 }
44 }
45 }
46 }
47
48 if (a != -1 && b != -1) {
49 System.out.println("Aresta " + contador_arestas++ + ": (" +
String.valueOf(a) + ", " + String.valueOf(b) + ") peso: " +
String.valueOf(min));
50 minP = minP + min;
51 arv_g[b] = arv_g[a] = true;
52 }
53 }
54 System.out.println("MENOR CUSTO = " + minP);
55 }
56
57 public static void principal(String caminho_arquivo) throws IOException {
58 BufferedReader br = new BufferedReader(new FileReader(caminho_arquivo));
59 int q_vert = 0;
60 while (br.ready()) { // ++++ quant de vert ++++
61 String lin = br.readLine();
62 lin = lin.replace("n", "");
63 String lin_vet[] = lin.split(",");
64 q_vert = lin_vet.length;
65 break;
66 }
67 br = new BufferedReader(new FileReader(caminho_arquivo));
68 int grafo[][] = new int[q_vert][q_vert];
69 int lin_corrente = 0;
70 while (br.ready()) {
71 String lin = br.readLine();

10. 72 lin = lin.replace("n", "");
73 String lin_vet[] = lin.split(",");
74 for (int i = 0; i < lin_vet.length; i++) {
75 if (Integer.parseInt(lin_vet[i]) == 0) {
76 grafo[lin_corrente][i] = Integer.MAX_VALUE;
77 continue;
78 }
79 grafo[lin_corrente][i] = Integer.parseInt(lin_vet[i]);
80 }
81 lin_corrente++;
82 }
83 prim(grafo, q_vert);
84 br.close();
85 }
86
87 public static void main(String[] args) throws IOException {
88 String caminho_arquivo = "";
89 principal(caminho_arquivo);
90 }
91 }
92

11. 1 //+++++++++++++++++++++++++++++++++++++++++++++++//
2 //ALUNO: JULIO CESAR DE ARAUJO MENEZES//
3 //PROFESSOR ORIENTADOR: DR. JÂNIO COUTINHO CANUTO//
4 //+++++++++++++++++++++++++++++++++++++++++++++++//
5
6 +++++++++ A N O T A Ç Õ E S +++++++++++++
7
8
9 +++ BellmanFord +++
10 v + (v*a) + a + v
11
12 +++ Djisktra +++
13 v + (v(v+v)) +v
14
15 +++ Kruskal +++
16 a + v + v(v+v+2v +a)
17
18 +++ Prim +++
19 v(v*v)
20
21
22 +++ Valores do Arquivo Utilizados no Calculo das Interações +++
23
24 0,0,0,0,0,0,0,0,0
25 0,0,3,0,2,0,0,0,0
26 0,6,0,0,0,0,0,9,0
27 0,0,2,0,4,0,0,0,0
28 0,0,8,0,0,0,13,0,0
29 0,0,0,1,12,0,8,0,0
30 0,0,0,0,3,0,0,1,8
31 2,2,0,0,17,0,0,0,0
32 0,0,2,0,1,0,0,0,0