Algoritmo de Dijkstra (um para todos ; arestas de peso não negativo ; guloso)

Transcrição

1 Algoritmo de Dijkstra (um para todos ; arestas de peso não negativo ; guloso) 1º passo: iniciam-se os valores: para todo v V[G] d[v] π[v] -1 d[s] 0 V[G] é o conjunto de vértices(v) que formam o Grafo G. d[v] é o vetor de distâncias de s até cada v. Admitindo-se a pior estimativa possível, o caminho infinito. π[v] identifica o vértice de onde se origina uma conexão até v de maneira a formar um caminho mínimo. 2º passo: temos que usar o conjunto Q, cujos vértices ainda não contém o custo do menor caminho d[v] determinado. Q V[G] 3º passo: realizamos uma série de relaxamentos das arestas, de acordo com o código: enquanto Q ø u extrair-mín(q) //Q Q - {u para cada v adjacente a u se d[v] > d[u] + w(u, v) //relaxe (u, v) então d[v] d[u] + w(u, v) π[v] u Q Q {v static void dijkstra(long A[][], int n){ boolean visitados[] = new boolean[n]; for (int i=1;i<n;i++){ int min = -1; long minval = Integer.MAX_VALUE; for (int j=1;j<n;j++){ if ((!visitados[j]) && (A[j][0] < minval)){ minval = A[j][0]; min = j; visitados[min] = true; for (int j=1;j<n;j++){ if (A[min][0] + A[min][j] < A[j][0]){ A[j][0] = A[min][0] + A[min][j];

2 Bellman Ford algorithm (um para todos ; arestas podem ter peso negativo) function BellmanFord(list vertices, list edges, vertex source) ::distance[],predecessor[] // This implementation takes in a graph, represented as // lists of vertices and edges, and fills two arrays // (distance and predecessor) with shortest-path // (less cost/distance/metric) information // Step 1: initialize graph for each vertex v in vertices: if v is source then distance[v] := 0 else distance[v] := inf predecessor[v] := null // Step 2: relax edges repeatedly for i from 1 to size(vertices)-1: for each edge (u, v) with weight w in edges: if distance[u] + w < distance[v]: distance[v] := distance[u] + w predecessor[v] := u // Step 3: check for negative-weight cycles for each edge (u, v) with weight w in edges: if distance[u] + w < distance[v]: error "Graph contains a negative-weight cycle" return distance[], predecessor[]

3 Algoritmo de Floyd-Warshall (todos para todos) ROTINA fw(inteiro[1..n,1..n] grafo) # Inicialização VAR Inteiro[1..n,1..n] dist := grafo VAR Inteiro[1..n,1..n] pred PARA i DE 1 A n PARA j DE 1 A n SE dist[i,j] < Infinito ENTÃO pred[i,j] := i # Laço principal do algoritmo PARA k DE 1 A n PARA i DE 1 A n PARA j DE 1 A n SE dist[i,j] > dist[i,k] + dist[k,j] ENTÃO dist[i,j] = dist[i,k] + dist[k,j] pred[i,j] = pred[k,j] RETORNE dist static void Floyd(long A[][], int n){ for(int x=0;x<n;x++){ for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ if (A[i][x]!= Integer.MAX_VALUE && A[x][j]!= Integer.MAX_VALUE && A[i][j] > ( A[i][x] + A[x][j])){ A[i][j]=A[i][x] + A[x][j];

4 class No{ int id; int numvizinhos; No[] vizinhos; boolean visitado; int cor; int distancia; No(){ No(int pid){ id = pid; import java.util.linkedlist; import java.util.random; public class Grafo { static final int INFINITO = Integer.MAX_VALUE/4; static int numnos; static boolean[][] adjacencias; static int[][] matrizdistancia; static boolean[] visitados; static boolean[] cores; static No nos[]; static int numcores = 5; static No[] solucao; static int[] tempsolucao; static int[] melhorsolucao; static int valormelhorsolucao; static int valorsolucaoatual; public Grafo(int n, int m){ numnos = n; adjacencias = new boolean[n][n]; visitados = new boolean[n]; nos = new No[n]; matrizdistancia = new int[n][n];

5 // Calcula o numero de componentes conexos de maneira recursiva utilizando a matriz de adjacencias private static int calcularcomponentesconexos4() { for (int i=0;i<numnos;i++) visitados[i] = false; int componentes = 0; for (int atual=0;atual<numnos;atual++){ if (!visitados[atual]){ componentes++; visitados[atual] = true; visitarvizinhos(atual); return componentes; private static void visitarvizinhos(int atual) { for (int v=0;v<numnos;v++){ if (!visitados[v] && adjacencias[atual][v]){ visitados[v] = true; visitarvizinhos(v);

6 // Calcula o numero de componentes conexos de maneira iterativa utilizando a matriz de adjacencias private static int calcularcomponentesconexos3() { int componentes = 0; LinkedList<Integer> lista = new LinkedList<Integer>(); int atual = 0; for (int i=0;i<numnos;i++){ atual = i; if (!visitados[atual]){ componentes++; visitados[atual] = true; lista.add(atual); while (!lista.isempty()){ atual = lista.remove(); for (int v=0;v<numnos;v++){ if (!visitados[v] && adjacencias[atual][v]){ visitados[v] = true; lista.add(v); return componentes; // Calcula o numero de componentes conexos de maneira recursiva utilizando o arranjo de vizinhos private static int calcularcomponentesconexos1() { int componentes = 0; for (int i=0;i<numnos;i++){ if (!nos[i].visitado){ componentes++; nos[i].visitado = true; visitarvizinhos(nos[i]); return componentes; private static void visitarvizinhos(no atual) { for (int v=0;v<atual.numvizinhos;v++){ if (!atual.vizinhos[v].visitado){ atual.vizinhos[v].visitado = true; visitarvizinhos(atual.vizinhos[v]);

7 // Calcula o numero de componentes conexos de maneira iterativa utilizando o arranjo de vizinhos private static int calcularcomponentesconexos2() { for (int i=0;i<numnos;i++){ nos[i].visitado = false; int componentes = 0; LinkedList<No> lista = new LinkedList<No>(); No atual; for (int i=0;i<numnos;i++){ atual = nos[i]; if (!atual.visitado){ componentes++; atual.visitado = true; lista.add(atual); while (!lista.isempty()){ atual = lista.remove(); for (int v=0;v<atual.numvizinhos;v++){ if (!atual.vizinhos[v].visitado){ atual.vizinhos[v].visitado = true; lista.add(atual.vizinhos[v]); return componentes;

8 Busca em Largura e em Profundidade private static int buscaemlargura(no inicio, No fim){ if (inicio == fim) return 0; LinkedList<No> ll = new LinkedList<No>(); inicio.distancia = 0; inicio.visitado = true; ll.add(inicio); No atual; while (!ll.isempty()){ atual = ll.remove(); for (No temp: atual.vizinhos){ if (!temp.visitado){ if (temp == fim) return atual.distancia + 1; temp.visitado = true; temp.distancia = atual.distancia + 1; ll.add(temp); return -1; private static int buscaemprofundidade(no atual, No fim, int visitados){ atual.visitado = true; if (atual == fim) return visitados; for (No temp: atual.vizinhos){ if (!temp.visitado){ int res = buscaemprofundidade(temp, fim, visitados+1); if (res > 0) return res; return -1; private static int buscaemprofundidade(no atual, No fim){ atual.visitado = true; if (atual == fim) return 0; for (No temp: atual.vizinhos){ if (!temp.visitado){ int res = buscaemprofundidade(temp, fim) + 1; if (res > 0) return res; return -1;

9 Ciclo Hamiltoniano private static boolean ciclohamiltoniano() { solucao = new No[nos.length]; nos[0].visitado = true; solucao[0] = nos[0]; return ciclohamiltonianoaux(1); private static boolean ciclohamiltonianoaux(int i) { if (i==nos.length){ for (No t: solucao[i-1].vizinhos) if (t == solucao[0]) return true; return false; for (No t: solucao[i-1].vizinhos){ if (!t.visitado){ t.visitado = true; solucao[i] = t; if (ciclohamiltonianoaux(i+1)) return true; t.visitado = false; return false;

10 Caixeiro Viajante private static int caixeiroviajante(int inicial ) { tempsolucao = new int[numnos]; melhorsolucao = new int[numnos]; valormelhorsolucao = INFINITO; valorsolucaoatual = 0; visitados[inicial] = true; tempsolucao[0] = inicial; caixeiroviajanteaux(1); if (valormelhorsolucao < INFINITO) return valormelhorsolucao; return -1; private static void caixeiroviajanteaux(int i) { if (valorsolucaoatual > valormelhorsolucao) return; if (i==numnos){ int dist = matrizdistancia[tempsolucao[i-1]][tempsolucao[0]] ; if (dist < INFINITO && valorsolucaoatual + dist < valormelhorsolucao) { System.out.println("\t" + valormelhorsolucao + " -> " + (valorsolucaoatual + dist)); valormelhorsolucao = valorsolucaoatual + dist; melhorsolucao = tempsolucao.clone(); return; int ultimo = tempsolucao[i-1]; for (int t=0;t<numnos;t++){ if (!visitados[t] && matrizdistancia[ultimo][t] < INFINITO){ visitados[t] = true; tempsolucao[i] = t; valorsolucaoatual += matrizdistancia[ultimo][t]; caixeiroviajanteaux(i+1); valorsolucaoatual -= matrizdistancia[ultimo][t]; visitados[t] = false;