Melhores momentos AULA 15

Transcrição

1 Melhores momentos AULA 5

2 Arborescência de caminhos mínimos Uma arborescência com raiz s é de caminhos mínimos (= shortest-paths tree = SPT) se para todo vértice t que pode ser alcançado a partir de s, o único caminho de s a t na arborescência é um caminho simples mínimo

3 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

4 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[]);

5 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, O(V) execuções de PQinsert, O(V) execuções de PQempty, O(V) execuções de PQdelmin, e O(A) execuções de PQdec.

6 AULA 6

7 Dijkstra para grafos esparços S. e.

8 Min-heap 8 nível

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

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

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

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

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

14 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];

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

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

17 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/;

18 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;

19 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.

20 Outra implementação para digrafos esparsos void DIGRAPHsptD (Digraph G, Vertex s, Vertex parnt[ ], double cst[ ]) { Vertex v, w; link p; PQinit(); for (v = ; v < G->V; v++) { parnt[v] = -; 5 cst[v] = INFINITO; 6 PQinsert(v); } 7 parnt[s] = s; 8 cst[s] = ; 9 PQdec(s);

21 Outra implementação para digrafos esparsos while (!PQempty()) { v = PQdelmin(); if (cst[v] == INFINITO) break; for (p=g->adj[v];p!=null;p=p->next){ w = p->w; 5 if (cst[w] > cst[v] + p->cst){ 6 cst[w] = cst[v] + p->cst; 7 PQdec(w); 8 parnt[w] = v; } } } }

22 Caminhos mínimos em DAGs S 9.6

23 DAGs Um digrafo é acíclico se não tem ciclos Digrafos acíclicos também são conhecidos como DAGs (= directed acyclic graphs) Exemplo: um digrafo acíclico 5

24 DAGs Um digrafo é acíclico se não tem ciclos Digrafos acíclicos também são conhecidos como DAGs (= directed acyclic graphs) Exemplo: um digrafo que não é acíclico 5

25 DAGs Um digrafo é acíclico se não tem ciclos Digrafos acíclicos também são conhecidos como DAGs (= directed acyclic graphs) Exemplo: um digrafo que não é acíclico 5

26 Ordenaçao topológica Uma permutação dos vértices de um digrafo é uma seqüência em que cada vértice aparece uma e uma só vez Uma ordenação topológica (= topological sorting) de um digrafo é uma permutação ts[], ts[],..., ts[v-] dos seus vértices tal que todo arco tem a forma ts[i]-ts[j] com i < j ts[] é necessariamente uma fonte ts[v-] é necessariamente um sorvedouro

27 Exemplo i 5 ts[i] 5 5

28 Fato Para todo digrafo G, vale uma e apenas umas das seguintes armações: G possui um ciclo G é um DAG e, portanto, admite uma ordenação topológica

29 Problema Problema: Dado um vértice s de um DAG com custos possivelmente negativos nos arcos, encontrar, para cada vértice t que pode ser alcançado a partir de s, um caminho mínimo simples de s a t Problema: Dado um vértice s de um DAG com custos possivelmente negativos nos arcos, encontrar uma SPT com raiz s

30 Simulação i 5 ts[i]

31 Simulação i 5 ts[i]

32 Simulação i 5 ts[i]

33 Simulação i 5 ts[i]

34 Simulação i 5 ts[i]

35 Simulação i 5 ts[i]

36 Simulação i 5 ts[i]

37 Simulação i 5 ts[i]

38 Simulação i 5 ts[i]

39 Simulação i 5 ts[i]

40 Simulação i 5 ts[i]

41 Simulação i 5 ts[i]

42 Simulação i 5 ts[i]

43 Simulação i 5 ts[i] 5 5 5

44 Simulação i 5 ts[i] 5 5 5

45 Simulação i 5 ts[i] 5 5 5

46 Simulação i 5 ts[i] 5 5 5

47 Simulação i 5 ts[i] 5 5 5

48 Simulação i 5 ts[i] 5 5

49 Simulação i 5 ts[i] 5 5

50 Simulação i 5 ts[i] 5 5

51 Simulação i 5 ts[i] 5 5

52 DAGmin A função DAGmin recebe um DAG G com custos possivelmente negativos e uma ordenação topológica ts de G. Recebe também um vértice s. Para cada vértice t, a função calcula o custo de um caminho de custo mínimo de sa t. Esse número é depositado em cst[t]. void DAGmin (Digraph G, Vertex ts[ ], Vertex s, double cst[ ])

53 void DAGmin DAGmin (Digraph G, Vertex ts[ ], Vertex s, double cst[ ]) { int i; Vertex v; link p; for (v= ; v < G->V; v++) cst[v] = INFINITO; cst[s] = ; 5 for (v = ts[i = ]; i < G->V; v = ts[i++]) 6 for (p=g->adj[v];p!=null;p=p->next) 7 if (cst[p->w] > cst[v] + p->cst) 8 cst[p->w] = cst[v] + p->cst; }

54 Consumo de tempo O consumo de tempo da função DAGmin é O(V + A).

55 Caminhos máximos em DAGs Do ponto de vista computacional, o problema de encontrar um caminho simples de custo máximo num digrafos com custos nos arcos é difícil. Mais precisamente, problema é NP-difícil como vocês verão no nal de Análise de Algoritmos. O problema torna-se fácil, entretanto, quando restrito a DAGs.

56 void DAGmax DAGmax (Digraph G, Vertex ts[ ], Vertex s, double cst[ ]) { int i; Vertex v; link p; for (v= ; v < G->V; v++) cst[v] = -INFINITO; cst[s] = ; 5 for (v= ts[i = ]; i < G->V; v = ts[i++]) 6 for (p=g->adj[v];p!=null;p=p->next) 7 if (cst[p->w] < cst[v] + p->cst) 8 cst[p->w] = cst[v] + p->cst; }

57 Consumo de tempo O consumo de tempo da função DAGmax é O(V + A).

58 Programação dinâmica

59 Programação dinâmica Propriedade (da subestrutura ótima) Se G é um digrafo com custo não-negativos nos arcos e v -v -v v k é um caminho mínimo então v i -v i v j é um caminho mínimo para i j k custo[v][w] = menor custo de uma caminho de v a w Propriedade O valor de custo[s][t] é min{custo[s][v] + custo[v][t] : v é vértice}

60 Programação dinâmica Propriedade (da subestrutura ótima) Se G é um digrafo com custo não-negativos nos arcos e v -v -v v k é um caminho mínimo então v i -v i v j é um caminho mínimo para i j k custo[v][w] = menor custo de uma caminho de v a w Propriedade O valor de custo[s][t] é min{custo[s][v] + custo[v][t] : v-t é arco}

61 Dijkstra em digrafos com custos negativos

62 Problema da SPT Problema: Dado um vértice s de um digrafo com custos possivelmente negativos nos arcos, encontrar uma SPT com raiz s Entra:

63 Problema da SPT Problema: Dado um vértice s de um digrafo com custos possivelmente negativos nos arcos, encontrar uma SPT com raiz s Sai:

64 Apelemos para Dijkstra

65 Apelemos para Dijkstra

66 Apelemos para Dijkstra

67 Apelemos para Dijkstra

68 Apelemos para Dijkstra

69 Apelemos para Dijkstra

70 Apelemos para Dijkstra

71 Apelemos para Dijkstra

72 Apelemos para Dijkstra

73 Apelemos para Dijkstra 6 7 6

74 Apelemos para Dijkstra 6 7 6

75 Apelemos para Dijkstra 6 7 6

76 Apelemos para Dijkstra 6 7 6

77 Apelemos para Dijkstra 6 7 6

78 Apelemos para Dijkstra 6 7 6

79 Apelemos para Dijkstra 6 7 6

80 Apelemos para Dijkstra 6 7 6

81 Apelemos para Dijkstra 6 7 6

82 Opsss O caminho mínimo de a tem custo e não...