FACULDADE ANHANGUERA DE TAUBAT UNIDADE II

ATIVIDADES PRTICAS
SUPERVISIONADAS
Estrutura de Dados
Prof.:
2 Bimestre / 2014

Curso: Cincia da Computao

Semestre: 3 e 4 - Turma A Ano: 2014

Taubat
02 de Dezembro de 2014
ETAPA 4.
1

Aula-tema: Grafos.
Passo 2 (Equipe).
Fazer a discusso da leitura do captulo do livro texto e do
material de aula, que ser utilizado como base para a
implementao de rotas de voos por meio da estrutura
grafo, com destaque para:
1. Representao de Grafos em C.
Os vrtices de um grafo sero representados por nmeros
inteiros no intervalo 0..v-1. O conjunto de vrtices ser,
portanto, 0 1 2 3...v-1.Vrtices so representados por
objetos do tipo Vertex.
#define Vertex int
Os arcos dos grafos sero representados por structs do tipo
Edge. Um objeto do tipo Edge representa um arco com
ponta inicial v e ponta final w.
typedef struct{
Vertex v;
Vertex w;
} Edge;
Se e um arco ento e.v a ponta inicial e e.w a ponta
final do arco. A construo de arcos ficar a cargo de uma
funo EDGE. A funo EDGE recebe dois vrtices v e w
e devolve um arco com ponta inicial v e ponta final w.
2

Edge EDGE (Vertex v, Vertex w){

Edge e;Teoria dos Grafos 3
e.v = v;
e.w = w;
return e;
}
2. Algoritmo de Menor Caminho.
O algoritmo de Dijkstra identifica, a partir de um vrtice
do grafo, qual o custo mnimo entre esse vrtice e todos
os outros do grafo. No incio, o conjunto S contm
somente esse vrtice, chamado origem. A cada passo,
selecionamos no conjunto de vrtices sobrando, o que o
mais perto da origem. Depois atualizamos, para cada
vrtice sobrando, a sua distncia em relao origem. Se
passando pelo novo vrtice acrescentado, a distncia fica
menor, essa nova distncia que ser memorizada.
Suponhamos que o grafo representado por uma matriz de
adjacncia onde no existe aresta entre dois vrtices.
Suponhamos tambm que os vrtices do grafo so
enumerados de 1 at n, isto , o conjunto de vrtices N =
{1, 2, ..., n}. Utilizaremos tambm um vetor D[2..n] que
conter a distncia que separa todo vrtice do vrtice 1 (o
vertce do grafo que o vertice 1 escolhido
arbitrariamente). Eis o algoritmo:
funo Dijkstra(L = [1..n, 1..n]: grafo): vetor[2..n]
C := {2,3,...,n} {Implicitamente S = N - C}
Para i := 2 at n:
D[i] := L[1,i]
3

Repetir n-2 vezes:

v := Elemento de C que minimiza D[v]
C := C - {v}
Para cada elemento w de C:
D[w] := min(D[w],D[v]+ L[v,w])
Retornar D
3. Representao por meio de Matriz de Adjacncia.
Seja G = (V, E) um grafo com n vrtices, onde n 1.
Supomos que os vrtices so numerados 1, 2, ..., |V| de
alguma maneira arbitrria. Ento a representao de
matriz de adjacncias de um grafo G consiste em uma
matriz |V| |V| A = (aij) tal que A(i,j) = 1 se a borda
(vi, vj)({vi, vj} para um grafo dirigido1) fica em E(G).
A matriz de adjacncias para um grafo no-dirigido2
simtrica, pois a borda (vi, vj) est em E(G), se a borda
(vi, vj) tambm est em E(G). A matriz de adjacncias de
um grafo dirigido no necessita ser simtrica. de n2 bits
o espao necessrio para representar um grafo, usando a
matriz de adjacncias.
A representao de matriz de adjacncias pode ser usada
no caso de grafos ponderados3. Por exemplo, se G = (V,
E) um grafo ponderado com funo peso de aresta w, o
peso w(u, v) da aresta (u, v) E simplesmente
armazenado como a entrada na fila u e na coluna v da
matriz de adjacncias.
A simplicidade de uma matriz de adjacncias pode torn-la
prefervel quando os grafos so razoavelmente pequenos.
Em lugar de usar uma palavra de memria de
computador para cada entrada da matriz, a matriz de
adjacncias usa somente um bit por entrada.
4

4. Caminhamento em Amplitude.
Em uma busca em largura a partir de um vrtice v,
esperamos que todos os vizinhos de v sejam visitados
antes de continuar a busca mais profundamente.
Contrariamente busca em profundidade, o algoritmo de
busca em largura no recursivo.
O algoritmo de busca em largura semelhante ao
algoritmo de busca em profundidade. A principal diferena
que usamos um fila F ao invs de uma pilha:
procedimento Busca-Largura(v: vrtice)
Inicializar F
Marcar v como visitado
Colocar v no final de F
Enquanto F no vazio:
u := primeiro elemento de F
Retirar u de F
Para cada vrtice w adjacente a u:
Se w no foi visitado:
Marcar w como visitado
Colocar w no final de F
Neste caso preciso um programa para lanar a busca:
procedimento Busca(G: Grafo)
Para cada vrtice v de G:
Marcar v como no visitado
Para cada vrtice v de G:
Se v no foi visitado:
{Busca-Largura ou Busca-Prof-iter}(v)
5

5. Caminhamento em Profundidade.
Seja um grafo G = (V,E) que contm n vrtices. Seja
tambem uma representao que indica, para cada vrtice,
se ele foi visitado ou no. Eis uma verso recursiva do
algoritmo de busca em profundidade que visita todos os
vrtices:
procedimento Busca(G: Grafo)
Para Cada vrtice v de G:
Marque v como no visitado
Para Cada vrtice v de G:
Se v no foi visitado:
Busca-Prof(v)
procedimento Busca-Prof(v: vrtice)
Marque v como visitado
Para Cada vrtice w adjacente a v:
Se w no foi visitado:
Busca-Prof(w)
Note que esse algoritmo funciona com um grafo
desconexo. Se j sabemos que o grafo conexo, podemos
chamar diretamente a funo Busca-Prof, escolhendo
arbitrariamento um vrtice inicial.

Passo 3 (Equipe).

#include<stdlib.h>
#include<stdio.h>
6

#include<conio.h>
void menu();
void selecao();
void montargrafo();
void caminhagrafo();
int main()
{
menu();
return 0;
system("pause");
}
void menu()
{
system("title Empresa VOEBEM");
printf("\t Empresa VOEBEM \n");
printf(" ____________________________\n");
printf(" | Escolha uma opcao abaixo |\n");
printf(" |--------------------------|\n");
printf(" | 1 - Cadastrar cidades
printf(" | 2 - Melhor rota
printf(" | 0 - Sair

|\n");
|\n");

|\n");

printf(" |__________________________|\n");
selecao();
}
void selecao()
{
int opcao;

printf("\n Digite uma das opcoes: ");

scanf("%i", &opcao);
switch (opcao)
{
case 1:
montargrafo();
menu();
break;
case 2:
caminhagrafo();
menu();
break;
case 0:
system("pause");
exit(0);
break;
default:
printf("\n\nOpcao nao encontrada.\nTente
Novamente\n\n");
system("pause");
system("cls");
menu();

break;
}
}

//FUNO MONTAR GRAFO (CADASTRO DE

CIDADES)
void montargrafo()
{
int num,I,J;
char cidade[10][10];
char A[10][10];
char B[10][10];
do
{
system("cls");
printf(" 1 - Cadastrar cidades\n\n");
for(I=0; I<10; I++)
{
printf(" Entre com a cidade numero %d: ",I);
fflush(stdin);
scanf("%s", &cidade[I]);
}
printf("\n\n Entre com a distancia das cidades:\n\n");
for(I=0; I<10; I++)
{
for(J=0; J<10; J++)
{
printf("\n Distancia entre %s e %s <Km>: ",
cidade[I],cidade[J]);
scanf("%s", &A[I][J]);
printf(" Tempo entre %s e %s <hrs>:
",cidade[I],cidade[J]);
scanf("%s", &B[I][J]);
9

}
}
printf(" ____________________________\n");
printf(" | Escolha uma opcao abaixo |\n");
printf(" |--------------------------|\n");
printf(" | 1 - Cadastrar cidades

|\n");

printf(" | 0 - Voltar ao menu

|\n");

printf(" |__________________________|\n");
printf("\n Opcao: ");
scanf("%d",&num);
}
while(num!=0);
system("cls");
}
//FUNO CAMINHO GRAFO (MELHOR CAMINHO)
void caminhagrafo()
{
int
aux,num,I,J,T,F,R,vet_resposta[10],menor,vet_caminho[10
],vet_peso[10],LUGAR_INICIAL,LUGAR_FINAL,NO_
ATUAL,N1,N2;
char cidade[10][10];
char A[10][10];
char B[10][10];
do
{
//PREENCHE OS VETORES CAMINHO E PESO

10

for(I=0; I<10; I++)

{
vet_caminho[I]=-1;
vet_peso [I]=0;
}
system("cls");
printf(" 2 - Melhor rota\n\n");
printf(" Entre a cidade inicial: ");
scanf("%d", &LUGAR_INICIAL);
N1=LUGAR_INICIAL;
printf(" Entre a cidade final: ");
scanf("%d", &LUGAR_FINAL);
N2=LUGAR_FINAL;
if(LUGAR_INICIAL != LUGAR_FINAL)
{
NO_ATUAL=LUGAR_INICIAL;
I=NO_ATUAL;
vet_caminho[I]= 1;
}
if(I<=10)
{
for(J=0; J<10; J++)
{
if(A[I][J] != 0)
{
if(vet_caminho[J]== 1)
{
if(vet_peso[J]> A[I][J])
{
11

if(vet_peso[J]>-1)
{
vet_peso[J]= A[I][J];
vet_peso[J]= B[I][J];
NO_ATUAL=I;
}
}
}
}
}
}
//verificando se o menor valor do vetor peso diferente de
-1 e a mesma posio no vetor caminho igual a F
menor= vet_peso[0];
for (T=0; T<10; T++)
{
if(vet_peso[T]< menor)
{
menor = vet_peso[T];
}
if(vet_peso[T]!=1)
{
if(vet_caminho[T]==F)
{
NO_ATUAL=I;
vet_resposta[I]=NO_ATUAL;
}
if(NO_ATUAL==LUGAR_FINAL)
{
12

for (R=0; R<10; R++)

{
if(vet_resposta[R]!=0)
{
aux=vet_resposta[R];
printf("\n %d melhor rota %dKm\n", R,
vet_resposta[R]);
}
else
I++;
}
}
}
}
printf(" ____________________________\n");
printf(" | Escolha uma opcao abaixo |\n");
printf(" |--------------------------|\n");
printf(" | 1 - Melhor rota
printf(" | 0 - Voltar ao menu

|\n");
|\n");

printf(" |__________________________|\n");
printf("\n Opcao: ");
scanf("%d",&num);
}
while(num!=0);
system("cls");
}

13

Passo 4 (Equipe).
Relatrio 4 Grafos.

14

Como solicitado na ATPS, produzimos um resumo sobre

implementao de uma estrutura grafo, destacando o uso
de representao de grafos em C, algoritmo de menor
caminho representao por meio de matriz de adjacncia,
caminho em amplitude e caminhamento em profundidade.
Em seguida, foi desenvolvido um programa para
implementao de um levantamento de rotas de duas
cidades por meio de um grafo.

Fonte de pesquisas.
https://docs.google.com/open?
id=0B_uLQd5hdqlWdU9tQi1yS1pTQXUzNEQ1d3BsbkZ
BUQ
Captulo 8: Grafos e Suas Aplicaes do livro texto
da disciplina de Estrutura de Dados (TENEMBAUM,
A.; LANGSAM, Y.; AUGESTEIN, M. Estrutura de
Dados usando C. 1 ed. So Paulo: Pearson, 2005. p.
408 a 425)
http://erinaldosn.files.wordpress.com/2011/02/aula-2representac3a7c3a3o.pdf
http://www.professeurs.polymtl.ca/michel.gagnon/Discipli
nas/Bac/Grafos/CaminhoMin/caminho_min.html
http://www.professeurs.polymtl.ca/michel.gagnon/Discipli
nas/Bac/Grafos/Busca/busca.html

15