Mtodos de Busca Heursticos Inteligncia Artificial

Ana Paula Grossi de Souza

Guloso Algoritmo de PRIM

#include<stdio.h>

#define MAX 10

#define TEMP 0

#define PERM 1

#define FALSE 0

#define TRUE 1

#define infinity 9999

struct node

int predecessor;

int dist;//distncia do predecessor

int status;

};

struct aresta

int u;

int v;

};

int adj[MAX][MAX];

int n;

main()

int i,j;

int path[MAX];

int peso_arvore,count;
 struct aresta arvore[MAX];

criar_grafo();

printf("Matriz de adjacncia :\n");

mostrar();

count = monta_arvore(arvore,&peso_arvore);

printf("Peso da MST : %d\n", peso_arvore);

printf("Arestas inclusas na MST : \n");

for(i=1;i<=count;i++)

printf("%d->",arvore[i].u);

printf("%d\n",arvore[i].v);

criar_grafo()

int i,max_arestas,origem,destino,peso;

printf("Nmero de vrtices : ");

scanf("%d",&n);

max_arestas=n*(n-1)/2;

for(i=1;i<=max_arestas;i++)

printf("Adicionar aresta %d(0 0 para encerrar) : ",i);

scanf("%d %d",&origem,&destino);

if((origem==0) && (destino==0)) break;

printf("Peso da aresta : ");

scanf("%d",&peso);

if( origem > n || destino > n || origem<=0 || destino<=0)

printf("INVLIDA!\n");

i--;
 }

else

adj[origem][destino]=peso;

adj[destino][origem]=peso;

if(i<n-1)

printf("MST no possvel\n");

exit(1);

mostrar()

int i,j;

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

printf("%3d",adj[i][j]);

printf("\n");

int monta_arvore(struct aresta arvore[MAX],int *weight)

struct node estado[MAX];

int i,k,min,count,atual,novadist;

int m;

int u1,v1;

*weight=0;
/*Ns temporrios*/

for(i=1;i<=n;i++)

estado[i].predecessor=0;

estado[i].dist = infinity;

estado[i].status = TEMP;

/*N permanente*/

estado[1].predecessor=0;

estado[1].dist = 0;

estado[1].status = PERM;

/*Comea do primeiro n*/

atual=1;

count=0;

/*count = nmero de ns*/

while(tornar_permanente(estado) != TRUE ) /*Loop at o n ficar permanente*/

for(i=1;i<=n;i++)

if ( adj[atual][i] > 0 && estado[i].status == TEMP )

if( adj[atual][i] < estado[i].dist )

estado[i].predecessor = atual;

estado[i].dist = adj[atual][i];

/*procurar ns temporrios com distncias mnimas e torn-los permanentes*/

min=infinity;
 for(i=1;i<=n;i++)

if(estado[i].status == TEMP && estado[i].dist < min)

min = estado[i].dist;

atual=i;

estado[atual].status=PERM;

/*inserir aresta na rvore*/

u1=estado[atual].predecessor;

v1=atual;

count++;

arvore[count].u=u1;

arvore[count].v=v1;

/*adicionar aresta ao peso da rvore*/

*weight=*weight+adj[u1][v1];

return (count);

/*retorna TRUE se todos os ns forem permanentes*/

int tornar_permanente(struct node estado[MAX] )

int i;

for(i=1;i<=n;i++)

if( estado[i].status == TEMP )

return FALSE;

return TRUE;

}
HILL CLIMBING

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

typedef struct fila { //Estrutura de fila para armazenar o caminho at a origem

int nome; //nome do n

struct fila* prox; //prximo n da fila

} Fila; //Estrutura Fila

typedef struct lista { //Estrutura de lista para armazenar os ns da arvore

int nome; //nome do n

int dist; //distancia at a origem

double dist_reta; //distncia em linha reta de F

struct fila* ant; //fila do caminho at a origem

struct lista* prox; //proximo n da lista

} Lista; //Estrutura Lista

int mat_adj[21][21]; //matriz adjacncia com os pesos

double dist_linha_reta[21]; //distncia em linha reta dos ns at 'F'

//A=0, B=1, C=2, D=3, E=4, F=5, G=6, H=7, I=8, K=9, L=10, M=11, N=12, P=13, Q=14, R=15,
S=16, T=17, U=18, V=19, W=20

void ini_dist_linha_reta()

dist_linha_reta[0] = 19.0; //A

dist_linha_reta[1] = 16.3; //B

dist_linha_reta[2] = 13; //C

dist_linha_reta[3] = 13.2; //D

dist_linha_reta[4] = 11; //E

 dist_linha_reta[5] = 0; //F

dist_linha_reta[6] = 9.6; //G

dist_linha_reta[7] = 11; //H

dist_linha_reta[8] = 19.7; //I

dist_linha_reta[9] = 11; //K

dist_linha_reta[10] = 18.3; //L

dist_linha_reta[11] = 9; //M

dist_linha_reta[12] = 12; //N

dist_linha_reta[13] = 9.1; //P

dist_linha_reta[14] = 9.1; //Q

dist_linha_reta[15] = 11; //R

dist_linha_reta[16] = 11.5; //S

dist_linha_reta[17] = 7.6; //T

dist_linha_reta[18] = 10; //U

dist_linha_reta[19] = 8.2; //V

dist_linha_reta[20] = 5.2; //W

void ini_mat_adj() //inicializar a matriz de adjacncia

int i, j, k; //vriaveis que podem ser usadas em rotinas

for(i=0; i<21; i++){ //inicializar a matriz com 0 em todas as posies

for(j=0; j<21; j++){

mat_adj[i][j] = 0;

//preencher a matriz com os pesos nas determinadas ligaes

mat_adj[0][1] = 3; //A - B

mat_adj[1][0] = 3; //B - A
mat_adj[0][8] = 3; //A - I

mat_adj[8][0] = 3; //I - A

mat_adj[1][2] = 4; //B - C

mat_adj[2][1] = 4; //C - B

mat_adj[1][8] = 4; //B - I

mat_adj[8][1] = 4; //I - B

mat_adj[1][17] = 11; //B - T

mat_adj[17][1] = 11; //T - B

mat_adj[2][3] = 3; //C - D

mat_adj[3][2] = 3; //D - C

mat_adj[2][4] = 3; //C - E

mat_adj[4][2] = 3; //E - C

mat_adj[3][4] = 2; //D - E

mat_adj[4][3] = 2; //E - D

mat_adj[4][6] = 3; //E - G

mat_adj[6][4] = 3; //G - E

mat_adj[6][7] = 3; //G - H

mat_adj[7][6] = 3; //H - G

mat_adj[6][9] = 3; //G - K

mat_adj[9][6] = 3; //K - G

mat_adj[7][9] = 2; //H - K

mat_adj[9][7] = 2; //K - H

mat_adj[9][5] = 8; //K - F

mat_adj[5][9] = 8; //F - K

mat_adj[5][20] = 8; //F - W

mat_adj[20][5] = 8; //W - F

mat_adj[5][11] = 8; //F - M

mat_adj[11][5] = 8; //M - F

mat_adj[20][17] = 3; //W - T

mat_adj[17][20] = 3; //T - W
 mat_adj[17][19] = 7; //T - V

mat_adj[19][17] = 7; //V - T

mat_adj[17][16] = 4; //T - S

mat_adj[16][17] = 4; //S - T

mat_adj[16][15] = 2; //S - R

mat_adj[15][16] = 2; //R - S

mat_adj[19][18] = 2; //V - U

mat_adj[18][19] = 2; //U - V

mat_adj[15][14] = 2; //R - Q

mat_adj[14][15] = 2; //Q - R

mat_adj[14][13] = 2; //Q - P

mat_adj[13][14] = 2; //P - Q

mat_adj[18][13] = 3; //U - P

mat_adj[13][18] = 3; //P - U

mat_adj[13][12] = 3; //P - N

mat_adj[12][13] = 3; //N - P

mat_adj[12][8] = 12; //N - I

mat_adj[8][12] = 12; //I - N

mat_adj[8][10] = 5; //I - L

mat_adj[10][8] = 5; //L - I

mat_adj[10][11] = 27; //L - M

mat_adj[11][10] = 27; //M - L

void imprime_mat_adj() //imprimir a matriz de adjacncia

int i, j, k;

printf("\tA\tB\tC\tD\tE\tF\tG\tH\tI\tK\tL\tM\t\tN\tP\tQ\tR\tS\tT\tU\tV\tW\n\n");
 for(i=0; i<21; i++){

switch(i) //como o nome dos ns esto como inteiros, os switchs so para

tranform-los em caracteres

case 0: printf("A\t");

break;

case 1: printf("B\t");

break;

case 2: printf("C\t");

break;

case 3: printf("D\t");

break;

case 4: printf("E\t");

break;

case 5: printf("F\t");

break;

case 6: printf("G\t");

break;

case 7: printf("H\t");

break;

case 8: printf("I\t");

break;

case 9: printf("K\t");

break;

case 10: printf("L\t");

break;

case 11: printf("M\t");

break;

case 12: printf("N\t");

break;

case 13: printf("P\t");

 break;

case 14: printf("Q\t");

break;

case 15: printf("R\t");

break;

case 16: printf("S\t");

break;

case 17: printf("T\t");

break;

case 18: printf("U\t");

break;

case 19: printf("V\t");

break;

case 20: printf("W\t");

break;

for(j=0; j<21; j++){

printf("%d\t", mat_adj[i][j]);

printf("\n\n");

void imprime_lista(Lista* p) //imprimir o primeiro n da Lista, o n que possui o caminho com o

menor custo

Fila *aux;

aux = p->ant;

printf("Caminho: ");
 while(aux->prox != NULL){

switch(aux->nome) //como o nome dos ns esto como inteiros, os switchs so

para tranform-los em caracteres

case 0: printf("A - ");

break;

case 1: printf("B - ");

break;

case 2: printf("C - ");

break;

case 3: printf("D - ");

break;

case 4: printf("E - ");

break;

case 5: printf("F - ");

break;

case 6: printf("G - ");

break;

case 7: printf("H - ");

break;

case 8: printf("I - ");

break;

case 9: printf("K - ");

break;

case 10: printf("L - ");

break;

case 11: printf("M - ");

break;

case 12: printf("N - ");

break;

case 13: printf("P - ");

 break;

case 14: printf("Q - ");

break;

case 15: printf("R - ");

break;

case 16: printf("S - ");

break;

case 17: printf("T - ");

break;

case 18: printf("U - ");

break;

case 19: printf("V - ");

break;

case 20: printf("W - ");

break;

aux = aux->prox;

switch(aux->nome) //como o nome dos ns esto como inteiros, os switchs so para

tranform-los em caracteres

case 0: printf("A");

break;

case 1: printf("B");

break;

case 2: printf("C");

break;

case 3: printf("D");

break;

case 4: printf("E");
break;

case 5: printf("F");

break;

case 6: printf("G");

break;

case 7: printf("H");

break;

case 8: printf("I");

break;

case 9: printf("K");

break;

case 10: printf("L");

break;

case 11: printf("M");

break;

case 12: printf("N");

break;

case 13: printf("P");

break;

case 14: printf("Q");

break;

case 15: printf("R");

break;

case 16: printf("S");

break;

case 17: printf("T");

break;

case 18: printf("U");

break;

case 19: printf("V");

 break;

case 20: printf("W");

break;

printf("\nA distancia percorrida foi: %d.\n", p->dist);

Fila* insere_fila(Fila* F_prim, int nome) //inserir elementos na fila de caminhos anteriores

Fila *aux=F_prim; //recebe a fila do n pai

Fila *f = (Fila*) malloc(sizeof(Fila));

f->nome = nome;

f->prox = NULL;

if(aux == NULL){ //se for o primeiro elemento a ser inserido na fila F_prim

F_prim = f;

else{ //seno n armazenado no final da fila

while(aux->prox != NULL)

aux = aux->prox;

aux->prox = f;

return F_prim;

Lista* cria_primeiro_no(int inicio) //funo para criar um primeiro n de lista

Lista *novo = (Lista*) malloc(sizeof(Lista)); //aloca memria para o n

novo->nome = inicio; //chama o n com o inicio inserido pelo usurio

 novo->dist = 0; //distncia zero por ser o primeiro n

novo->dist_reta = dist_linha_reta[inicio]; //heuristica do primeiro n

novo->ant = NULL; //no tem antecessores

novo->prox = NULL; //no existe prximo n na lista

return novo; //retorna novo n

Lista* busca_hillclimbing(int inicio, int fim) //buscar o vizinho com menor heuristica (hill climbing)

int i, j, k, dist; //variveis auxiliares

double menor; //varivel para saber o menor valor dos vizinhos

Lista *atual; //n atual

Lista *vizinho; //n vizinho

atual = cria_primeiro_no(inicio); //cria n atual

vizinho = cria_primeiro_no(inicio); //cria n vizinho

while(1){ //loop at achar um n que no possui vizinhos menores

menor = 100; //sempre atualizar o valor de menor para 100

atual->ant = insere_fila(atual->ant, atual->nome); //antecessor de atual ser ele

mesmo

for(i=0; i<21; i++){ //nmero de ns

if(mat_adj[atual->nome][i] > 0){ //se existir ligao entre o primeiro

elemento da lista(atual) e outro vrtice(vizinho)

if(dist_linha_reta[i] < menor){ //procurar a menor heuristica

entre os vizinhos

vizinho->nome = i; //nome do vizinho recebe i

vizinho->dist = atual->dist + mat_adj[atual->nome][i];

//distancia do pai at a origem mais o peso da aresta
 vizinho->dist_reta = dist_linha_reta[i]; //heuristica do
vizinho

vizinho->ant = atual->ant; //vizinho recebe o caminho

de atual

vizinho->prox = NULL; //no existe n prximo

menor = dist_linha_reta[i]; //menor atualizado com a

heuristica

if(atual->dist_reta <= vizinho->dist_reta) //se o menor vizinho for maior que o

atual

return atual; //retorna o n atual (acha o mnimo (local ou global))

//se vizinho for menor atual atualizado para vizinho

atual->nome = vizinho->nome;

atual->dist = vizinho->dist;

atual->dist_reta = vizinho->dist_reta;

atual->prox = vizinho->prox;

main()

int inicio, fim;

//clock_t tempoInicial, tempoFinal;

//double tempoGasto;

Lista *L_prim=NULL;

printf("\n\nA=0, B=1, C=2, D=3, E=4, F=5, G=6, H=7, I=8, K=9, L=10, M=11, N=12,
P=13, Q=14, R=15, S=16, T=17, U=18, V=19, W=20\n\n");

printf("Insira o Inicio: ");

scanf("%d", &inicio); //armazenar inicio

 ini_mat_adj(); //inicializar matriz de adjacncia

ini_dist_linha_reta(); //inicializar distncias em linha reta at 'F'

//tempoInicial = clock();

L_prim = busca_hillclimbing(inicio, 5); //procurar caminho entre a origem e 'F' com a

menor distncia em linha reta

//tempoFinal = clock();

//tempoGasto = (tempoFinal-tempoInicial)/(CLOCKS_PER_SEC/1000);

//printf("\n\nTempo em segundos: %f\n\n", tempoGasto);

imprime_lista(L_prim); //imprimir o primeiro elemento da lista

}
A*

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

typedef struct fila { //Estrutura de fila para armazenar o caminho at a origem

int nome; //nome do n

struct fila* prox; //prximo n da fila

} Fila; //Estrutura Fila

typedef struct lista { //Estrutura de lista para armazenar os ns da arvore

int nome; //nome do n

int dist; //distancia at a origem

double dist_reta; //distncia em linha reta de F

double est_custo; //f(n) para o A*

struct fila* ant; //fila do caminho at a origem

struct lista* prox; //proximo n da lista

} Lista; //Estrutura Lista

int mat_adj[21][21]; //matriz adjacncia com os pesos

double dist_linha_reta[21]; //distncia em linha reta dos ns at 'F'

//A=0, B=1, C=2, D=3, E=4, F=5, G=6, H=7, I=8, K=9, L=10, M=11, N=12, P=13, Q=14, R=15,
S=16, T=17, U=18, V=19, W=20

void ini_dist_linha_reta()

dist_linha_reta[0] = 19.0; //A

dist_linha_reta[1] = 16.3; //B

dist_linha_reta[2] = 13; //C

dist_linha_reta[3] = 13.2; //D

 dist_linha_reta[4] = 11; //E

dist_linha_reta[5] = 0; //F

dist_linha_reta[6] = 9.6; //G

dist_linha_reta[7] = 11; //H

dist_linha_reta[8] = 19.7; //I

dist_linha_reta[9] = 11; //K

dist_linha_reta[10] = 18.3; //L

dist_linha_reta[11] = 9; //M

dist_linha_reta[12] = 12; //N

dist_linha_reta[13] = 9.1; //P

dist_linha_reta[14] = 9.1; //Q

dist_linha_reta[15] = 11; //R

dist_linha_reta[16] = 11.5; //S

dist_linha_reta[17] = 7.6; //T

dist_linha_reta[18] = 10; //U

dist_linha_reta[19] = 8.2; //V

dist_linha_reta[20] = 5.2; //W

void ini_mat_adj() //inicializar a matriz de adjacncia

int i, j, k; //vriaveis que podem ser usadas em rotinas

for(i=0; i<21; i++){ //inicializar a matriz com 0 em todas as posies

for(j=0; j<21; j++){

mat_adj[i][j] = 0;

//preencher a matriz com os pesos nas determinadas ligaes

mat_adj[0][1] = 3; //A - B
mat_adj[1][0] = 3; //B - A

mat_adj[0][8] = 3; //A - I

mat_adj[8][0] = 3; //I - A

mat_adj[1][2] = 4; //B - C

mat_adj[2][1] = 4; //C - B

mat_adj[1][8] = 4; //B - I

mat_adj[8][1] = 4; //I - B

mat_adj[1][17] = 11; //B - T

mat_adj[17][1] = 11; //T - B

mat_adj[2][3] = 3; //C - D

mat_adj[3][2] = 3; //D - C

mat_adj[2][4] = 3; //C - E

mat_adj[4][2] = 3; //E - C

mat_adj[3][4] = 2; //D - E

mat_adj[4][3] = 2; //E - D

mat_adj[4][6] = 3; //E - G

mat_adj[6][4] = 3; //G - E

mat_adj[6][7] = 3; //G - H

mat_adj[7][6] = 3; //H - G

mat_adj[6][9] = 3; //G - K

mat_adj[9][6] = 3; //K - G

mat_adj[7][9] = 2; //H - K

mat_adj[9][7] = 2; //K - H

mat_adj[9][5] = 8; //K - F

mat_adj[5][9] = 8; //F - K

mat_adj[5][20] = 8; //F - W

mat_adj[20][5] = 8; //W - F

mat_adj[5][11] = 8; //F - M

mat_adj[11][5] = 8; //M - F

mat_adj[20][17] = 3; //W - T
 mat_adj[17][20] = 3; //T - W

mat_adj[17][19] = 7; //T - V

mat_adj[19][17] = 7; //V - T

mat_adj[17][16] = 4; //T - S

mat_adj[16][17] = 4; //S - T

mat_adj[16][15] = 2; //S - R

mat_adj[15][16] = 2; //R - S

mat_adj[19][18] = 2; //V - U

mat_adj[18][19] = 2; //U - V

mat_adj[15][14] = 2; //R - Q

mat_adj[14][15] = 2; //Q - R

mat_adj[14][13] = 2; //Q - P

mat_adj[13][14] = 2; //P - Q

mat_adj[18][13] = 3; //U - P

mat_adj[13][18] = 3; //P - U

mat_adj[13][12] = 3; //P - N

mat_adj[12][13] = 3; //N - P

mat_adj[12][8] = 12; //N - I

mat_adj[8][12] = 12; //I - N

mat_adj[8][10] = 5; //I - L

mat_adj[10][8] = 5; //L - I

mat_adj[10][11] = 27; //L - M

mat_adj[11][10] = 27; //M - L

void imprime_mat_adj() //imprimir a matriz de adjacncia

int i, j, k;

printf("\tA\tB\tC\tD\tE\tF\tG\tH\tI\tK\tL\tM\t\tN\tP\tQ\tR\tS\tT\tU\tV\tW\n\n");
 for(i=0; i<21; i++){

switch(i) //como o nome dos ns esto como inteiros, os switchs so para

tranform-los em caracteres

case 0: printf("A\t");

break;

case 1: printf("B\t");

break;

case 2: printf("C\t");

break;

case 3: printf("D\t");

break;

case 4: printf("E\t");

break;

case 5: printf("F\t");

break;

case 6: printf("G\t");

break;

case 7: printf("H\t");

break;

case 8: printf("I\t");

break;

case 9: printf("K\t");

break;

case 10: printf("L\t");

break;

case 11: printf("M\t");

break;

case 12: printf("N\t");

break;
 case 13: printf("P\t");

break;

case 14: printf("Q\t");

break;

case 15: printf("R\t");

break;

case 16: printf("S\t");

break;

case 17: printf("T\t");

break;

case 18: printf("U\t");

break;

case 19: printf("V\t");

break;

case 20: printf("W\t");

break;

for(j=0; j<21; j++){

printf("%d\t", mat_adj[i][j]);

printf("\n\n");

void imprime_lista(Lista* p) //imprimir o primeiro n da Lista, o n que possui o caminho com o

menor custo

Fila *aux;

aux = p->ant;

printf("Caminho: ");
 while(aux != NULL){

switch(aux->nome) //como o nome dos ns esto como inteiros, os switchs so

para tranform-los em caracteres

case 0: printf("A - ");

break;

case 1: printf("B - ");

break;

case 2: printf("C - ");

break;

case 3: printf("D - ");

break;

case 4: printf("E - ");

break;

case 5: printf("F - ");

break;

case 6: printf("G - ");

break;

case 7: printf("H - ");

break;

case 8: printf("I - ");

break;

case 9: printf("K - ");

break;

case 10: printf("L - ");

break;

case 11: printf("M - ");

break;

case 12: printf("N - ");

break;
 case 13: printf("P - ");

break;

case 14: printf("Q - ");

break;

case 15: printf("R - ");

break;

case 16: printf("S - ");

break;

case 17: printf("T - ");

break;

case 18: printf("U - ");

break;

case 19: printf("V - ");

break;

case 20: printf("W - ");

break;

aux = aux->prox;

switch(p->nome) //como o nome dos ns esto como inteiros, os switchs so para

tranform-los em caracteres

case 0: printf("A");

break;

case 1: printf("B");

break;

case 2: printf("C");

break;

case 3: printf("D");

break;

case 4: printf("E");
break;

case 5: printf("F");

break;

case 6: printf("G");

break;

case 7: printf("H");

break;

case 8: printf("I");

break;

case 9: printf("K");

break;

case 10: printf("L");

break;

case 11: printf("M");

break;

case 12: printf("N");

break;

case 13: printf("P");

break;

case 14: printf("Q");

break;

case 15: printf("R");

break;

case 16: printf("S");

break;

case 17: printf("T");

break;

case 18: printf("U");

break;

case 19: printf("V");

 break;

case 20: printf("W");

break;

printf("\nA distancia percorrida foi: %d.\n", p->dist);

Fila* insere_fila(Fila* F_prim, int nome) //inserir elementos na fila de caminhos anteriores

Fila *aux=F_prim; //recebe a fila do n pai

Fila *f = (Fila*) malloc(sizeof(Fila));

f->nome = nome;

f->prox = NULL;

if(aux == NULL){ //se for o primeiro elemento a ser inserido na fila F_prim

F_prim = f;

else{ //seno n armazenado no final da fila

while(aux->prox != NULL)

aux = aux->prox;

aux->prox = f;

return F_prim;

Lista* insere_lista(Lista* L_prim, int nome, int dist, double dist_l, Fila* ant, int nome_ant) //inserir
na lista ordenadamente

Lista *p = L_prim;

Lista *prim;

Fila *aux;
 double est = dist + dist_l;

Lista *novo = (Lista*) malloc(sizeof(Lista));

Fila *F_prim = NULL;

aux = ant;//fila de caminho do n pai

while(aux != NULL){ //pegar todos os caminhos do n pai e armazenar na fila do n

filho

F_prim = insere_fila(F_prim, aux->nome);

aux = aux->prox;

//se for filho da raiz, n j recebe s um elemento, que seria o pai

F_prim = insere_fila(F_prim, nome_ant);//armazenar n pai

//definio do n a ser aberto na rvore

novo->nome = nome;

novo->dist = dist;

novo->dist_reta = dist_l;

novo->est_custo = est;

novo->ant = F_prim;

novo->prox = NULL;

if(p->prox != NULL){

prim = p;

p = p->prox;

while(p->prox != NULL && p->est_custo < est){ //at ltimo n ou at distncia

for menor

prim = p;

p = p->prox;

}
 if (est < p->est_custo){ //distancia menor que o primeiro elemento da lista

novo->prox = p;

prim->prox = novo; //primeiro elemento da lista passa a ser o novo

elemento

else{ //seno adiciona onde o 'while' parou

novo->prox = p->prox;

p->prox = novo;

else{

novo->prox = p->prox;

p->prox = novo;

return L_prim;

Lista* cria_primeiro_no(int inicio)

Lista *novo = (Lista*) malloc(sizeof(Lista));

novo->nome = inicio;

novo->dist = 0;

novo->dist_reta = dist_linha_reta[inicio];

novo->est_custo = dist_linha_reta[inicio];

novo->ant = NULL;

novo->prox = NULL;

return novo;

}
Lista* retira(Lista* L_prim) //retirar o primeiro elemento da lista

Lista *aux;

aux = L_prim;

L_prim = aux->prox;

free(aux);

return L_prim;

Lista* busca_guloso(Lista* L_prim, int inicio, int fim) //buscar o caminho de menor custo

int i, j, k, dist;

double dist_l;

L_prim = cria_primeiro_no(inicio);

while(L_prim->nome != fim) { //enquanto o destino no for o primeiro elemento da lista,

que seria o menor caminho at o destino

for(i=0; i<21; i++){

if(mat_adj[L_prim->nome][i] > 0){ //se existir ligao entre o primeiro

elemento da lista(pai) e outro vrtice(filho)

dist = L_prim->dist + mat_adj[L_prim->nome][i]; //distancia do

pai at a origem mais o peso da aresta

dist_l = dist_linha_reta[i];

L_prim = insere_lista(L_prim, i, dist, dist_l, L_prim->ant, L_prim-

>nome); //abre um n na arvore

}
 L_prim = retira(L_prim);//retira o primeiro elemento da lista(pai), pois ele foi
aberto gerando os filhos

return L_prim;

main()

int inicio, fim;

clock_t tempoInicial, tempoFinal;

double tempoGasto;

Lista *L_prim=NULL;

printf("\n\nA=0, B=1, C=2, D=3, E=4, F=5, G=6, H=7, I=8, K=9, L=10, M=11, N=12,
P=13, Q=14, R=15, S=16, T=17, U=18, V=19, W=20\n\n");

printf("Insira o Inicio: ");

scanf("%d", &inicio); //armazenar inicio

ini_mat_adj(); //inicializar matriz de adjacncia

ini_dist_linha_reta(); //inicializar distncias em linha reta at 'F'

tempoInicial = clock();

L_prim = busca_guloso(L_prim, inicio, 5); //procurar caminho entre a origem e 'F' com a
menor distncia em linha reta

tempoFinal = clock();

tempoGasto = (tempoFinal-tempoInicial)/(CLOCKS_PER_SEC/1000);

printf("\n\nTempo em segundos: %f\n\n", tempoGasto);

imprime_lista(L_prim); //imprimir o primeiro elemento da lista

}