Melhores momentos AULA 14

Transcrição

1 Melhores momentos AULA

2 Problema O algoritmo de Dijkstra resolve o problema da SPT: Dado um vértice s de um digrafo com custos não-negativos nos arcos, encontrar uma SPT com raiz s 5 5 5

3 Simulação 5

4 Simulação 5

5 Simulação 5

6 Simulação 5

7 Simulação 5

8 Simulação 5

9 Simulação 5

10 Simulação 5

11 Simulação 5

12 Simulação 5

13 Simulação 5 5

14 Simulação 5 5

15 Simulação 5 5

16 Simulação 5 5

17 Simulação 5 5

18 Simulação 5

19 Simulação 5

20 Simulação 5

21 Simulação 5

22 Simulação 6 5

23 Simulação 6 5

24 Simulação 6 5

25 Simulação 6 5

26 Simulação 6 6 5

27 Simulação 6 6 5

28 Simulação 6 6 5

29 Simulação 6 6 5

30 Simulação 6 6 5

31 Simulação 6 6 5

32 dijkstra Recebe digrafo G com custos não-negativos nos arcos e um vértice s Calcula uma arborescência de caminhos mínimos com raiz s. A arborescência é armazenada no vetor parnt As distâncias em relação a s são armazenadas no vetor cst void dijkstra(digraph G, Vertex s, Vertex parnt[], double cst[]);

33 Fila com prioridades A função dijkstra usa uma la com prioridades A la é manipulada pelas seguintes funções: PQinit(): inicializa uma la de vértices em que cada vértice v tem prioridade cst[v] PQempty(): devolve se a la estiver vazia e em caso contrário PQinsert(v): insere o vértice v na la PQdelmin(): retira da la um vértice de prioridade mínima. PQdec(w): reorganiza a la depois que o valor de cst[w] foi decrementado.

34 dijkstra #dene INFINITO maxcst void dijkstra(digraph G, Vertex s, { Vertex parnt[], double cst[]); Vertex v, w; link p; for (v = ; v < G->V; v++) { cst[v] = INFINITO; parnt[v] = -; } 5 PQinit(G->V); 6 cst[s] = ; parnt[s] = s;

35 dijkstra 8 PQinsert(s); 9 while (!PQempty()) { v = PQdelmin(); for(p=g->adj[v];p!=null;p=p->next) if (cst[w=p->w]==infinito) { cst[w]=cst[v]+p->cst; parnt[w]=v; 5 PQinsert(w); }

36 dijkstra 6 else if(cst[w]>cst[v]+g->adj[v][w]) 8 cst[w]=cst[v]+g->adj[v][w]; 9 parnt[w] = v; PQdec(w); } } }

37 Conclusão O consumo de tempo da função dijkstra é O(V + A) mais o consumo de tempo de execução de PQinit e PQfree, V execuções de PQinsert, V + execuções de PQempty, V execuções de PQdelmin, e A execuções de PQdec.

38 Conclusão O consumo de tempo da função dijkstra é O(V ). Este consumo de tempo é ótimo para digrafos densos.

39 AULA 5

40 Mais algoritmo de Dijkstra S. e.

41 Relações invariantes S = vértices examinados Q = vértices visitados = vértices na la U = vértices ainda não visitados (i) não existe arco v-w com v em S e w em U S Q U

42 Relações invariantes (i) para cada u em S, v em Q e w em U cst[u] cst[v] cst[w] S Q U u v w

43 Relações invariantes (i) O vetor parnt restrito aos vértices de S e Q determina um árborescência com raiz s s S Q U

44 Relações invariantes (i) Para arco v-w na arborescência vale que cst[w] = cst[v] + custo do arco vw s S Q U

45 Relações invariantes (i) Para cada arco v-w com v ou w em S vale que cst[w] cst[v] custo do arco vw s S Q U

46 Relações invariantes (i5) Para cada vértice v em S vale que cst[v] é o custo de um caminho mínimo de s a v. s S Q U

47 Iteração s S v Q U

48 Iteração s S Q U v

49 Iteração s S Q U v

50 Outra implementação para digrafos densos #dene INFINITO maxcst void DIGRAPHsptD (Digraph G, Vertex s, Vertex parnt[], double cst[]) { Vertex w, w, fr[maxv]; for (w = ; w < G->V; w++) { parnt[w] = -; cst[w] = INFINITO; 5 } 6 fr[s] = s; cst[s] = ;

51 8 while () { 9 double mincst = INFINITO; for (w = ; w < G->V; w++) if (parnt[w]==- && mincst>cst[w]) mincst = cst[w=w]; if (mincst == INFINITO) break; parnt[w] = fr[w]; 5 for (w = ; w < G->V; w++) 6 if(cst[w]>cst[w]+g->adj[w][w]) { cst[w] = cst[w]+g->adj[w][w]; 8 fr[w] = w; } } }

52 Dijkstra para digrafos esparços S. e.

53 Representação de árvores em vetores puta que o pariu!!! nível

54 Pais e filhos A[.. m] é um vetor representando uma árvore. Diremos que para qualquer índice ou nó i, i/ é o pai de i ; i é o filho esquerdo de i ; i + é o filho direito. Todo nó i é raiz da subárvore formada por A[i, i, i +, i, i +, i +, i +, 8i,..., 8i +,...]

55 Min-heap nível

56 Rotina básica de manipulação de max-heap Recebe A[.. m] e i tais que subárvores com raiz i e i + são min-heaps e rearranja A de modo que subárvore com raiz i seja min-heap.

57 Rotina básica de manipulação de min-heap 5 nível

58 Rotina básica de manipulação de min-heap 8 nível

59 Rotina básica de manipulação de min-heap 8 nível

60 Rotina básica de manipulação de min-heap 8 nível

61 Rotina básica de manipulação de min-heap 8 nível

62 Implementação clássica Min-Heap O vetor qp é o "inverso" de pq: para cada vértice v, qp[v] é o único índice tal que pq[qp[v]] == v. É claro que qp[pq[i]]==i para todo i. static Vertex pq[maxv+]; static int N; static int qp[maxv];

63 PQinit, PQempty, PQinsert void PQinit(void) { N = ; } int PQempty(void) { return N == ; } void PQinsert(Vertex v) { } qp[v] = ++N; pq[n] = v; fixup(n);

64 PQdelmin e PQdec Vertex PQdelmin(void) { exch(, N); --N; fixdown(); return pq[n+]; } void PQdec(Vertex w) { } fixup(qp[w]);

65 exch e fixup static void exch(int i, int j) { Vertex t; t = pq[i]; pq[i] = pq[j]; pq[j] = t; qp[pq[i]] = i; qp[pq[j]] = j; } static void fixup(int i) { while (i> && cst[pq[i/]]>cst[pq[i]]){ } } exch(i/, i); i = i/;

66 fixdown static void fixdown(int i) { int j; while (*i <= N) { } } j = *i; if (j< N && cst[pq[j]] > cst[pq[j+]]) j++; if (cst[pq[i]] <= cst[pq[j]]) break; exch(i, j); i = j;

67 Consumo de tempo Min-Heap heap d-heap bonacci heap PQinsert O(lg V) O(log D V) O() PQdelmin O(lg V) O(log D V) O(lg V) PQdec O(lg V) O(log D V) O() dijkstra O(A lg V) O(A log D V) O(A + V lg V)

68 Consumo de tempo Min-Heap bucket heap radix heap PQinsert O() O(lg(VC)R PQdelmin O(C) O(lg(VC) PQdec O() O(A + V lg(vc)) dijkstra O(A + VC) O(A + V lg(vc)) C = maior custo de um arco.

69 Conclusão O consumo de tempo da função dijkstra implementada com um min-heap é O(A lg V). Este consumo de tempo é ótimo para digrafos esparsos.