JoãoPereira01

A parte do Transp eu tinha entendido só estou mais enrolado na parte final o meu código ta dando muito erro mesmo que eu faça alterações Sim, mas não foi coisas muito avançadas era coisas mais básicas mas no momento eu só estou precisando para entregar o trabalho ai vou ter mais tempo de ver com calma sabe ? Ai dá tempo de treinar fazendo códigos Eu poderia usar essa lista como um exemplo ? // Grafos - Lista de adjacência #include <iostream> #include <list> #include <algorithm> // função find using namespace std; class Grafo { int V; // número de vértices list<int> *adj; // ponteiro para um array contendo as listas de adjacências public: Grafo(int V); // construtor void adicionarAresta(int v1, int v2); // adiciona uma aresta no grafo // obtém o grau de saída de um dado vértice // grau de saída é o número de arcos que saem de "v" int obterGrauDeSaida(int v); bool existeVizinho(int v1, int v2); // verifica se v2 é vizinho de v1 }; Grafo::Grafo(int V) { this->V = V; // atribui o número de vértices adj = new list<int>[V]; // cria as listas } void Grafo::adicionarAresta(int v1, int v2) { // adiciona vértice v2 à lista de vértices adjacentes de v1 adj[v1].push_back(v2); } int Grafo::obterGrauDeSaida(int v) { // basta retornar o tamanho da lista que é a quantidade de vizinhos return adj[v].size(); } bool Grafo::existeVizinho(int v1, int v2) { if(find(adj[v1].begin(), adj[v1].end(), v2) != adj[v1].end()) return true; return false; } int main() { // criando um grafo de 4 vértices Grafo grafo(4); // adicionando as arestas grafo.adicionarAresta(0, 1); grafo.adicionarAresta(0, 3); grafo.adicionarAresta(1, 2); grafo.adicionarAresta(3, 1); grafo.adicionarAresta(3, 2); // mostrando os graus de saída cout << "Grau de saida do vertice 1: " << grafo.obterGrauDeSaida(1); cout << "\nGrau de saida do vertice 3: " << grafo.obterGrauDeSaida(3); // verifica se existe vizinhos if(grafo.existeVizinho(0, 1)) cout << "\n\n1 eh vizinho de 0\n"; else cout << "\n\n1 não eh vizinho de 0\n"; if(grafo.existeVizinho(0, 2)) cout << "2 eh vizinho de 0\n"; else cout << "2 não eh vizinho de 0\n"; return 0; }

Se eu entendi direito eu posso simplesmente descartar essa parta para não dar o erro ? Ata você usou somente para resolver o inicio da questão e já que eu vou querer saber o resultado final sendo envolvido outra problemática n tem como usar Trasp. Você consegue me indicar algum vídeo para eu me aprofundar mais sobre o processo de listagem

Sim, eu só fiquei com uma duvida Transp* menorCaminho(); Eu posso usar o Transp* menorCaminho para descobrir o menor caminho para percorrer ? E o que eu poderia colocar dentro do parenteses ? Sendo que eu vou colocar só código abaixo dele no caso seria esse mas não sei se vou ter que fazer alterações for(i=0;i<n;i++) if(i!=inicial){ printf("\nDistancia do no %d = %d",i,distancia[i]); printf("\nCaminho = %d",i); j=i; do{ j=pred[j]; printf("<-%d",j); }while(j!=inicial); } }

Realmente eu fui ensinado da forma mais complicada e realmente dessa forma dava muitos números aleatórios tive que mexer bastante para sumir isso mas o jeito que você falou facilita muito vou passar a usar somente assim. Me ajudou bastante consegui aprender mais aqui do que com o meu atual professor kkkkkkk Para o caso de fazer o menor custo para o maior eu teria que usar algo desse tipo para começar a construção ?

Ataa ele é o que esta na primeira linha entendi achei que era outro botão desculpa da próxima eu coloco Acabei me confundindo em relação a esse tópico de baixo Você conseguiria me dar um exemplo sobre isso, de como se faz comparando com o que eu fiz ? Eu conseguiria compreender melhor sou novo nessa área estou aprendendo aos poucos

@arfneto Mexi bastante nesse código e tentei colocar o máximo de coisas que você falou nas dicas mas ainda ta faltando parte e eu estou perdido novamente, acho que dá para entender melhor sobre o que se trata o exercício e ficou dessa forma : #include<stdio.h> #define QTD 9999 #define MAX 5 void dijkstra(int G[MAX][MAX],int n,int inicial); int main(){ int i,j,u,l,p; int G[MAX][MAX]; printf("Sabendo que seu RA é 2110696 digite um digito por vez para ver o menor caminho a seguir:\n"); for(l=0 ;l < MAX; l++){ for( p=0; p< MAX; p++){ G[l][p] = 0; } } printf("\n"); G[0][1]=200; G[0][2]=100; G[1][3]=100; G[1][4]=0; G[2][1]=600; G[2][3]=900; G[4][3]=600; for(l=0 ;l < MAX; l++){ for( p=0; p< MAX; p++){ printf("%d,",G[l][p]); } printf("\n"); } printf("\nInforme o número inicial:"); scanf("%d",&u); dijkstra(G,MAX,u); return 0; } void dijkstra(int G[MAX][MAX],int n,int inicial) { int custo[n][n],distancia[n],pred[n]; int visitado[n],cont,distanciamin,proxno,i,j; for(i=0;i<n;i++) for(j=0;j<n;j++) if(G[i][j]==-1) custo[i][j]=QTD; else custo[i][j]=G[i][j]; for(i=0;i<n;i++){ distancia[i]=custo[inicial][i]; pred[i]=inicial; visitado[i]=0; } distancia[inicial]=0; visitado[inicial]=1; cont=1; while(cont<n-1){ distanciamin=QTD; for(i=0;i<n;i++) if(distancia[i]<distanciamin&&!visitado[i]){ distanciamin=distancia[i]; proxno=i; } //verifica se existe melhor caminho atraves do proximo node visitado[proxno]=1; for(i=0;i<n;i++){ if(!visitado[i]) if(distanciamin+custo[proxno][i]<distancia[i]){ distancia[i]=distanciamin+custo[proxno][i]; pred[i]=proxno; } } cont++; } //imprime o caminho e a distancia de cada node for(i=0;i<n;i++) if(i!=inicial){ printf("\nDistancia do no %d = %d",i,distancia[i]); printf("\nCaminho = %d",i); j=i; do{ j=pred[j]; printf("<-%d",j); }while(j!=inicial); } } Não consegui fazer sem o uso das letras pois só sei essa forma de resolver

@arfneto Então cara... De fato está confuso mas não tenho culpa do que o meu professor passou como base para fazer o trabalho, mas se ainda tiver dicas uteis para a melhor resolução estou aberto para discussões. Estou tentando fazer uma forma que deixe mais claro o código mesmo que ainda tendo algumas partes que estão fora da minha compreensão, mas mesmo assim vou postar aqui na esperança que alguém possa me ajudar. Agradeço mesmo assim o esforço que você teve em tentar me ajudar!

Uma transportadora especializada em grãos opera nas cinco regiões do Brasil, tendo o porto de Santos como seu destino final. Você pode observar as rotas de operações a partir do grafo a seguir: O porto de Santos é o vértice indicado pelo número 5 (cinco). As demais regiões são representadas pelos demais vértices que vão de 1 (um) a 4 (quatro). Você foi convidado a desenvolver uma solução que ajude a empresa em uma tomada de decisão, pois devido ao aumento consecutivo do valor do diesel, a empresa quer uma estimativa de quais os menores custos para continuar operando no porto de Santos. Foi feito um levantamento histórico com o custo médio de operação em cada ponto de origem até o destino final. No contexto da figura, os vértices 1, 2, 3, 4 e 5 representam, respectivamente as regiões cidades em que a transportadora opera hoje. O trajeto é representado pelas arestas que liga (1 a 2), (1 a 3), (2 a 4), (2 a 5), e assim por diante. O custo médio (peso) entre cada conexão está representado por X. Você deve substituir o X pelos 7 primeiros dígitos do seu RA (indo da esquerda para direita) multiplicado por 100, na sequência: (1-2), (1-3), (2-4), (2-5), (3-2), (3-5), (4-5). Exemplo: RA 2025703-5 = Será utilizado os seguintes números do seu RA 2025703 RA 202570-5 = Em caso de 6 dígitos, acrescentar o dígito 1 ao final 2025701 (1-2) = 2 * 100 = 200 (1-3) = 0 * 100 = 0 (2-4) = 2 * 100 = 200 ...... Considerando que você precisa desenvolver a solução, utilize o algoritmo de Dijkstra e informe o caminho de menor custo saindo de 1 (que é a matriz da empresa em Mato Grosso do Sul) e chegando em 5. O resultado do seu programa deverá indicar as rotas que poderão ser utilizadas pela companhia e o seu respectivo peso. Passos para realizar o Mapa: 1. Desenvolva um programa em linguagem C, salvar com a extensão (.c) que informe os caminhos saindo de 1 e chegando em 5. 1.1. Neste código, usuário deverá excetuar as seguintes ações: - informar o número de vértices (ponto de rota), - informar as arestas com suas respectivas rotas de origem e destino, - informar o custo correspondente ao seu RA para todas as rotas. 1.2. Cálcular rotas. 1.3. Apresentar na tela todos os destinos com os seus respectivos pesos. 2. Após a impressão (item 1.3) tirar um print da sua tela de forma que pegue todos os destinos. - Neste print marque o(s) caminho(s) de menor custo saindo de 1 e chegando em 5 (usar qualquer programa de edição de imagem) Esse foi o modo que eu fiz para a alteração com meu RA: Nesse código falta transferir o numero do meu RA e adicionar o menor para o maior caminho no final foi essa parte que me deixou mais confuso: #include <stdio.h> #include <stdlib.h> #include <math.h> int destino, origem, vertices = 0; int custo, *custos = NULL; void dijkstra(int vertices,int origem,int destino,int *custos); void menu_mostrar(void); void grafo_procurar(void); void grafo_criar(void); int main(int argc, char **argv) { int opt = -1; do { menu_mostrar(); scanf("%d", &opt); switch (opt) { case 1: grafo_criar(); break; case 2: if (vertices > 0) { grafo_procurar(); } break; } } while (opt != 0); printf("\nAlgoritmo de Dijkstra inalizado...\n\n"); system("pause"); return 0; } void dijkstra(int vertices,int origem,int destino,int *custos) { int i, v, cont = 0; int *ant, *tmp; int *z; double min; double dist[vertices]; ant = (int*) calloc (vertices, sizeof(int *)); if (ant == NULL) { system("color fc"); printf ("** Erro: Memória Insuficiente **"); exit(-1); } tmp = (int*) calloc (vertices, sizeof(int *)); if (tmp == NULL) { system("color fc"); printf ("** Erro: Memória Insuficiente **"); exit(-1); } z = (int *) calloc (vertices, sizeof(int *)); if (z == NULL) { system("color fc"); printf ("** Erro: Memória Insuficiente **"); exit(-1); } for (i = 0; i < vertices; i++) { if (custos[(origem - 1) * vertices + i] !=- 1) { ant[i] = origem - 1; dist[i] = custos[(origem-1)*vertices+i]; } else { ant[i]= -1; dist[i] = HUGE_VAL; } z[i]=0; } z[origem-1] = 1; dist[origem-1] = 0; do { min = HUGE_VAL; for (i=0;i<vertices;i++){ if (!z[i]){ if (dist[i]>=0 && dist[i]<min) { min=dist[i];v=i; } } } if (min != HUGE_VAL && v != destino - 1) { z[v] = 1; for (i = 0; i < vertices; i++){ if (!z[i]) { if (custos[v*vertices+i] != -1 && dist[v] + custos[v*vertices+i] < dist[i]) { dist[i] = dist[v] + custos[v*vertices+i]; ant[i] =v; } } } } } while (v != destino - 1 && min != HUGE_VAL); printf("\tDe %d para %d: \t", origem, destino); if (min == HUGE_VAL) { printf("não Existe\n"); printf("\tCusto: \t- \n"); } else { i = destino; i = ant[i-1]; while (i != -1) { tmp[cont] = i+1; cont++; i = ant[i]; } for (i = cont; i > 0 ; i--) { printf("%d -> ", tmp[i-1]); } printf("%d", destino); printf("\n\tCusto: %d\n",(int) dist[destino-1]); } } void grafo_criar(void){ do { printf("\nInforme o numero de vertices (no minimo 3 "); scanf("%d", &vertices); } while (vertices < 3 ); if (!custos) { free(custos); } custos = (int *) malloc(sizeof(int)*vertices*vertices); if (custos == NULL) { system("color fc"); printf ("** Erro: Memoria Insuiciente **"); exit(-1); } for (int i = 0; i <= vertices * vertices; i++){ custos[i] = -1; } do { system("cls"); printf("Entre com as Arestas:\n"); do { printf("Origem (entre 1 e %d ou ‘0’ para sair): ", vertices); scanf("%d", &origem); } while (origem < 0 || origem > vertices); if (origem) { do { printf("Destino (entre 1 e %d, menos %d): ", vertices, origem); scanf("%d", &destino); } while (destino < 1 || destino > vertices || destino == origem); do { printf("Custo (positivo) do vertice %d para o vertice %d: ", origem, destino); scanf("%d",&custo); } while (custo < 0); custos[(origem-1) * vertices + destino - 1] = custo; } } while (origem); } void grafo_procurar(void){ int i, j; system("cls"); system("color 03"); printf("Lista dos Menores Caminhos no Grafo Dado: \n"); for (i = 1; i <= vertices; i++) { for (j = 1; j <= vertices; j++) { dijkstra(vertices, i,j, custos); } printf("\n"); } system("pause"); system("color 07"); } void menu_mostrar(void){ system("cls"); printf("Implementacao do Algoritmo de Dijasktra\n"); printf("opções:\n"); printf("\t 1 - Adicionar um Grafo\n"); printf("\t 2 - Procura Os Menores Caminhos no Grafo\n"); printf("\t 0 - Sair do programa\n"); printf("? "); }