Aula 09. Percurso em grafo

Transcrição

1 Logo

2 Aula 09 Percurso em grafo 2

3 Percurso de grafo Veremos agora a pesquisa em profundidade e pesquisa em largura de um grafo. Ambos os algoritmos recebem um nó inicial no grafo, e eles visitam todos os nós que podem ser alcançados a partir do nó inicial. A diferença nos algoritmos é a ordem em que eles visitam os nós. 3

4 Pesquisa em Profundidade - DFS A pesquisa de profundidade (DFS Depth-First Search) é uma técnica direta de passagem de grafo. O algoritmo começa em um nó de partida e prossegue para todos os outros nós acessíveis a partir do nó inicial usando as arestas do grafo. A pesquisa em profundidade primeiro segue sempre um único caminho no grafo, desde que ele encontre novos nós. Depois disso, ele retorna aos nós anteriores e começa a explorar outras partes do grafo. O algoritmo faz o controle dos nós visitados, de modo que ele processa cada nó apenas uma vez. 4

5 Exemplo Considere a pesquisa em profundidade processada no seguinte grafo:

6 Exemplo Podemos começar a pesquisa em qualquer nó do grafo; vamos começar a pesquisa no nó 1. A pesquisa primeiro passa para o nó 2:

7 Exemplo Depois disso, os nós 3 e 5 serão visitados:

8 Exemplo Os vizinhos do nó 5 são 2 e 3, mas a pesquisa já visitou ambos, então é hora de retornar aos nós anteriores. Além disso, os vizinhos dos nós 3 e 2 foram visitados, então passamos do nó 1 para o nó 4:

9 Exemplo Depois disso, a pesquisa termina porque visitou todos os nós. A complexidade do tempo da pesquisa em profundidade é O(n + m) onde n é o número de nós e m é o número de arestas, porque o algoritmo processa cada nó e aresta uma vez. 9

10 Implementação A pesquisa de profundidade pode ser convenientemente implementada usando recursão. A seguinte função dfs inicia uma busca em profundidade em um determinado nó. A função pressupõe que o grafo é armazenado como listas de adjacência em um vetor vector<int> adj[n]; e também mantém um vetor bool visited[n]; 10

11 Implementação que acompanha os nós visitados. Inicialmente, cada valor do vetor é falso, e quando a pesquisa chega no nó s, o valor de visited[s] é verdadeiro. A função pode ser implementada da seguinte forma: void dfs(vector<int> adj[], bool visited[], int s) { vector <int> ::iterator it; if (visited[s]) return; visited[s] = true; cout << s << " "; for (it = adj[s].begin(); it!= adj[s].end(); it++) { dfs(adj, visited, *it); } } 11

12 Programa #include <bits/stdc++.h> using namespace std; void addedge(vector<int> adj[], int u, int v) { adj[u].push_back(v); adj[v].push_back(u); } 12

13 Programa void dfs(vector<int> adj[], bool visited[], int s) { vector <int> ::iterator it; if (visited[s]) return; visited[s] = true; cout << s << " "; for (it = adj[s].begin(); it!= adj[s].end(); it++) { dfs(adj, visited, *it); } } 13

14 Programa int main() { int V, i, N, x, y, ini; freopen("entrada.txt", "r", stdin); scanf("%d %d", &V, &N); vector<int> G[V]; bool visited[v]; memset (visited, 0, sizeof(visited)); 14

15 Programa } for (i = 0; i < N; i++) { scanf("%d %d", &x, &y); addedge(g, x, y); } scanf("%d", &ini); cout << "DFS iniciando no vertice " << ini << ":\n"; dfs(g, visited, ini); cout << "\n"; return 0; 15

16 Programa Entrada:

17 Programa Saída: DFS iniciando no vertice 2:

18 Pesquisa em Largura - BFS A pesquisa em largura (BFS Breadth-First Search) visita os nós em ordem crescente da distância do nó inicial. Assim, podemos calcular a distância do nó de partida para todos os outros nós usando a pesquisa em largura. No entanto, a pesquisa em largura em primeiro lugar é mais difícil de implementar do que a pesquisa em profundidade. A primeira pesquisa passa pelos nós um nível após o outro. Primeiro, a pesquisa explora os nós cuja distância do nó inicial é 1, então os nós cuja distância é 2 e assim por diante. Esse processo continua até que todos os nós tenham sido visitados. 18

19 Exemplo Considere a pesquisa em largura processada no seguinte grafo:

20 Exemplo Suponha que a pesquisa começa no nó 1. Primeiro, processamos todos os nós que podem ser alcançados a partir do nó 1 usando uma única vantagem:

21 Exemplo Depois disso, seguimos para os nós 3 e 5:

22 Exemplo Finalmente, visitamos o nó 6:

23 Exemplo Agora, calculamos as distâncias do nó inicial para todos os nós do grafo. As distâncias são as seguintes: Nó Distância Como a pesquisa em profundidade, a complexidade do tempo da busca em largura é O(n + m), onde n é o número de nós e m é o número de arestas. 23

24 Implementação O BFS é mais difícil de implementar do que a pesquisa em profundidade, porque o algoritmo visita nós em diferentes partes do grafo. Uma implementação típica é a baseada em uma fila que contém nós. Em cada etapa, o próximo nó na fila será processado. O código a seguir pressupõe que o grafo é armazenado como listas de adjacência e mantém as seguintes estruturas de dados: queue<int> q; bool visited[n]; int distance[n]; 24

25 Implementação A fila q contém nós a serem processados em ordem crescente da distância deles. Novos nós são sempre adicionados ao final da fila e o nó no início da fila é o próximo nó a ser processado. O vetor visited indica quais os nós que a pesquisa já visitou e a distância da disposição conterá as distâncias do nó inicial para todos os nós do grafo. 25

26 Implementação A pesquisa pode ser implementada da seguinte forma, começando no nó x: void bfs(vector<int> adj[], bool visited[], int distance[], int x) { queue<int> q; vector <int> ::iterator it; visited[x] = true; distance[x] = 0; q.push(x); 26

27 Implementação } while (!q.empty()) { int s = q.front(); q.pop(); cout << s << " "; for (it = adj[s].begin(); it!= adj[s].end(); it++) { if (visited[*it]) continue; visited[*it] = true; distance[*it] = distance[s]+1; q.push(*it); } } 27

28 Programa #include <bits/stdc++.h> using namespace std; void addedge(vector<int> adj[], int u, int v) { adj[u].push_back(v); adj[v].push_back(u); } 28

29 Programa } while (!q.empty()) { int s = q.front(); q.pop(); cout << s << " "; for (it = adj[s].begin(); it!= adj[s].end(); it++) { if (visited[*it]) continue; visited[*it] = true; distance[*it] = distance[s]+1; q.push(*it); } } 29

30 Programa int main() { int V, i, N, x, y, ini; freopen("entrada.txt", "r", stdin); scanf("%d %d", &V, &N); vector<int> G[V]; int distance[v]; bool visited[v]; memset (visited, 0, sizeof(visited)); for (i = 0; i < N; i++) { scanf("%d %d", &x, &y); addedge(g, x, y); } 30

31 Programa } scanf("%d", &ini); cout << "BFS iniciando no vertice " << ini << ":\n"; bfs(g, visited, distance, ini); cout << "\n"; printf("no\tdistancia\n"); for (i = 0; i < V; i++) { printf("%2d\t %d\n", i, distance[i]); } return 0; 31

32 Programa Entrada:

33 Programa Saída: BFS iniciando no vertice 2: No Distancia

34 Aplicação Usando os algoritmos de cruzamento de grafos, podemos verificar muitas propriedades de grafos. Geralmente, tanto a pesquisa em profundidade quanto a pesquisa em largura podem ser usadas, mas na prática, a pesquisa em profundidade é uma escolha melhor, porque é mais fácil de implementar. Nas seguintes aplicações, assumiremos que o grafo não está direcionado. 34

35 Verificação de Conectividade Um grafo está conectado se houver um caminho entre os dois nós do grafo. Assim, podemos verificar se um grafo está conectado começando em um nó arbitrário e descobrindo se podemos alcançar todos os outros nós. Por exemplo, no grafo

36 Verificação de Conectividade uma pesquisa em profundidade primeiro do nó 2 visita os seguintes nós: Uma vez que a pesquisa não visitou todos os nós, podemos concluir que o grafo não está conectado. Da mesma forma, também podemos encontrar todos os componentes conectados de um grafo, iterando através dos nós e sempre iniciando uma nova pesquisa em profundidade primeiro se o nó atual ainda não pertencer a nenhum componente. 4 36

37 Encontrado Ciclos Um grafo contém um ciclo, se durante uma passagem no grafo, encontrarmos um nó cujo vizinho (diferente do nó anterior no caminho atual) já foi visitado. Por exemplo, o grafo

38 Encontrado Ciclos contém dois ciclos e podemos encontrar um deles da seguinte forma:

39 Controle de Bipartiência Um grafo é bipartido se seus nós podem ser coloridos usando duas cores para que não haja nós adjacentes com a mesma cor. É surpreendentemente fácil verificar se um grafo é bipartido usando algoritmos de cruzamento de grafos. A ideia é colorir o nó de partida azul, todos os seus vizinhos vermelhos, todos os vizinhos azuis, e assim por diante. Se em algum momento da pesquisa percebemos que dois nós adjacentes têm a mesma cor, isso significa que o grafo não é bipartido. Caso contrário, o grafo é bipartido e uma cor foi encontrada. 39

40 Exercícios Faça os exercícios de Grafos do URI. 40

41 Contest Warmup e final 41

42 Contest Warmup e final 42

43 Contest Warmup e final 43

44 Contest Warmup e final 44

45 Contest Warmup e final 45

46 Contest Warmup e final 46

47 Contest Warmup e final 47

48 Contest Warmup e final 48

49 Contest Warmup e final 49

50 Contest Warmup e final 50