Runtime Error 402 MASH uva - c

I just started doing uva problems. However in problem 402 no matter what I do the result of my submission is always runtime error. I cannot understand where is my problem or why is it resulting in errors. Can anyone help, please?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct nodo
{
int info;
struct nodo *sig;
};
struct nodo *p, *q, *nuevo;
void Insertar(int n)
{
int i; //Contador
struct nodo *nuevo;
for(i = 0; i < n; i++)
{
nuevo = (struct nodo*)malloc(sizeof(struct nodo));
nuevo->info = i+1;
if(!p)
p = nuevo;
else
q->sig=nuevo;
q = nuevo;
q->sig = 0;
}
}
void Borrar()
{
struct nodo *aux;
}
int main()
{
int m,s,cont=0,cartas[22],i,j,k;
while(scanf("%i %i",&m,&s)==2)
{
if(cont)
printf("\n");
cont++;
for(i = 0; i < 20; i++)
scanf("%i",&cartas[i]);
printf("Selection #%i\n",cont);
Insertar(m);
for(i = 0, s = m-s; i < 20 && s; i++)
{
j = cartas[i] - 2;
if(j == -1)
{
while(s)
{
nuevo=p->sig;
free(p);
p = nuevo;
s--;
}
}
else
{
nuevo = p;
while(nuevo->sig)
{
for(k = 0; k < j && nuevo->sig; nuevo = nuevo->sig, k++);
if(nuevo->sig)
{
q = nuevo->sig;
nuevo->sig = q->sig;
free(q);
nuevo = nuevo->sig;
s--;
if(!s)
break;
}
}
}
}
printf("%i",p->info);
nuevo = p->sig;
free(p);
while(nuevo)
{
printf(" %i",nuevo->info);
p = nuevo->sig;
free(nuevo);
nuevo = p;
}
printf("\n");
}
}

Related

List vector print does not work

I'm doing a hash table, where I have a one vector with a list inside each node of it. But when I go to print it does not appear the items that are within the list, and if I try to put more than one element in the list, it gives segmentation failure in the second. Below is the code and the result:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
enum erro {
semErro = 0, posInv = 1, listaCheia = 2, listaVazia = 3, existe = 4, naoExiste = 5
};
typedef struct no{
char nome[100];
char telefone[20];
struct no *prox;
} nodo;
typedef struct{
int tamanho;
nodo *inicio;
} lista;
typedef struct {
int tamanhoTabelaHash;
int colisoes;
lista* vetor;
} tabela;
///////////////////Chamada de Funções///////////////////
lista *novaLista();
tabela *criaTabela(int tam);
int insereTabela(tabela *tabela, char *entraNome, char *entraTelefone);
int insereNoInicioI(lista *lista,char *entraNome, char *entraTelefone);
int hash1(char *entraNome, int tam);
void imprime(lista *lista);
void imprimeTabela(tabela *tabela);
///////////////////Funções Lista///////////////////
void imprime(lista *lista){
int i;
nodo *no; //<<<<<Possível local do erro>>>>>
puts("Lista: \n");
for (i = 0; i < lista->tamanho; i++) {
printf("Nome: %s Telefone: %s\n",no->nome,no->telefone);
no=no->prox;
}
}
lista *novaLista(){
lista *l = (lista*)malloc(sizeof(lista));
l->tamanho=0;
l->inicio=NULL;
return l;
}
int insereNoInicioI(lista *lista,char *entraNome, char *entraTelefone){
nodo *novo=(nodo *)malloc(sizeof(nodo));
strcpy(novo->nome,entraNome);
strcpy(novo->telefone,entraTelefone);
novo->prox = lista->inicio;
lista->inicio = novo;
lista->tamanho++;
return semErro;
}
tabela *criaTabela(int tam) {
if( tam < 1 ) return NULL;
tabela *table = (tabela *)malloc(sizeof(tabela));
table->tamanhoTabelaHash = tam;
table->colisoes = 0;
for (int i = 0; i < 10; i++) {
table[i].vetor = NULL;
}
return table;
}
void imprimeTabela(tabela *tabela) {
int i;
printf("\nTabela: \n");
for (i = 0; i < tabela->tamanhoTabelaHash ; i++) {
printf("\nindice[%d]:", i);
if(tabela[i].vetor!=NULL){
imprime(tabela[i].vetor);
}
}
}
int insereTabela(tabela *tabela, char *entraNome, char *entraTelefone){
int pos = 0;
pos = hash1(entraNome,10000);//Função que retorna uma posição( no caso 8 para o primeiro nome e 6 para o segundo e terceiro
}
if(tabela[pos].vetor==NULL){
lista *list = novaLista();
tabela[pos].vetor = list;
}
nodo *novo=(nodo *)malloc(sizeof(nodo));
insereNoInicioI(tabela[pos].vetor, entraNome, entraTelefone);
return semErro;
}
int main(){
setlocale(LC_ALL, "Portuguese");
tabela *table = criaTabela(10);
char nome[100] = "Maria Cláudia Feliz";
char telefone[20] = "(53)98401-8583";
char nome1[100] = "Everton Almeida";
char telefone1[20] = "(53)90000-8583";
char nome2[100] = "Everton Almeida";
char telefone2[20] = "(53)90000-8583";
insereTabela(table,nome,telefone);
insereTabela(table,nome1,telefone1);
insereTabela(table,nome2,telefone2);
imprimeTabela(table);
return semErro;
}
Resultado:
Tabela:
indice[0]:
indice[1]:
indice[2]:
indice[3]:
indice[4]:
indice[5]:
indice[6]:Lista:
Nome: Telefone: //<<<<Deveria imprimir o nome e telefone>>>>
Nome: Telefone: //<<<<Deveria imprimir o nome e telefone>>>>
indice[7]:
indice[8]:Lista:
//<<<<Deveria imprimir o nome e telefone>>>>
Falha de segmentação(imagem do núcleo gravada)
If you can help, thank you.

You have at least one serious problem here:
tabela *criaTabela(int tam) {
if (tam < 1) return NULL;
// you allocate space for 1 tabela
tabela *table = (tabela *)malloc(sizeof(tabela));
table->tamanhoTabelaHash = tam;
table->colisoes = 0;
// but here you write to 10 tabelas ....
for (int i = 0; i < 10; i++) {
table[i].vetor = NULL;
}
return table;
}
You if you write to 10 tabelas, you should allocate space for 10 tabelas:
tabela *table = (tabela *)malloc(sizeof(tabela) * 10);
The code in your answer yields in undefined bahaviour. In other works it may appear to work. Google "undefined bahaviour".
There may be more problems elsewhere in your code.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
enum erro {
semErro = 0, posInv = 1, listaCheia = 2, listaVazia = 3, existe = 4, naoExiste = 5
};
typedef struct no{
char nome[100];
char telefone[20];
struct no *prox;
} nodo;
typedef struct{
int tamanho;
nodo *inicio;
} lista;
typedef struct {
int tamanhoTabelaHash;
int colisoes;
lista* vetor;
} tabela;
///////////////////Chamada de Funções///////////////////
lista *novaLista();
tabela *criaTabela(int tam);
int insereTabela(tabela *tabela, char *entraNome, char *entraTelefone);
int insereNoInicioI(lista *lista,char *entraNome, char *entraTelefone);
int hash1(char *entraNome, int tam);
void imprime(lista *lista);
void imprimeTabela(tabela *tabela);
///////////////////Funções Lista///////////////////
void imprime(lista *lista){
int i;
nodo *no = lista-> inicio;
puts("Lista: \n");
for (i = 0; i < lista->tamanho; i++) {
printf("Nome: %s Telefone: %s\n",no->nome,no->telefone);
no=no->prox;
}
}
lista *novaLista(){
lista *l = (lista*)malloc(sizeof(lista));
l->tamanho=0;
l->inicio=NULL;
return l;
}
int insereNoInicioI(lista *lista,char *entraNome, char *entraTelefone){
nodo *novo=(nodo *)malloc(sizeof(nodo));
strcpy(novo->nome,entraNome);
strcpy(novo->telefone,entraTelefone);
novo->prox = lista->inicio;
lista->inicio = novo;
lista->tamanho++;
return semErro;
}
tabela *criaTabela(int tam) {
if( tam < 1 ) return NULL;
tabela *table = (tabela *)malloc(sizeof(tabela)*10);
table->tamanhoTabelaHash = tam;
table->colisoes = 0;
for (int i = 0; i < 10; i++) {
table[i].vetor = NULL;
}
return table;
}
void imprimeTabela(tabela *tabela) {
int i;
printf("\nTabela: \n");
for (i = 0; i < tabela->tamanhoTabelaHash ; i++) {
printf("\nindice[%d]:", i);
if(tabela[i].vetor!=NULL){
imprime(tabela[i].vetor);
}
}
}
int hash1(char *string, int tam) {
int tamanho = strlen(string);
unsigned soma = 0;
for (int i = 0; i < tamanho; i++) {
soma = soma * 251 + string[i];
}
return soma % tam;
}
int insereTabela(tabela *tabela, char *entraNome, char *entraTelefone){
int pos = 0;
pos = hash1(entraNome,10);
if(tabela[pos].vetor==NULL){
lista *list = novaLista();
tabela[pos].vetor = list;
}
nodo *novo=(nodo *)malloc(sizeof(nodo));
insereNoInicioI(tabela[pos].vetor, entraNome, entraTelefone);
return semErro;
}
int main(){
setlocale(LC_ALL, "Portuguese");
tabela *table = criaTabela(10);
char nome[100] = "Maria Cláudia Feliz";
char telefone[20] = "(53)98401-8583";
char nome1[100] = "Everton Almeida";
char telefone1[20] = "(53)90000-8583";
char nome2[100] = "Everton Almeida";
char telefone2[20] = "(53)90000-8583";
insereTabela(table,nome,telefone);
insereTabela(table,nome1,telefone1);
insereTabela(table,nome2,telefone2);
imprimeTabela(table);
return semErro;
}
Resultado:
indice[0]:
indice[1]:
indice[2]:Lista:
Nome: Everton Almeida Telefone: (53)90000-8583
indice[3]:
indice[4]:
indice[5]:Lista:
Nome: Everton Telefone: (53)90000-8583
indice[6]:
indice[7]:
indice[8]:Lista:
Nome: Maria Cláudia Feliz Telefone: (53)98401-8583
indice[9]:
Thanks to all comments THIS IS THE CODE WORKING, but I have one more doubt, because the name clause goes wrong if the setlocale (LC_ALL, "Portuguese");

Linked List pointers prob

I do not know why this is not working.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// struct of list
typedef struct noeud
{
int adresse, taille, temp;
struct noeud* suivant;
} * liste;
int random(int a, int b)
{
return (a + (rand() % ((b + 1) + a)));
}
void initialisation(liste* LBO)
{
*LBO = NULL;
}
I think it's here the problem when I create q (q is created to point to the previous node).
void creation(liste* LBO)
{
liste q, prec = NULL;
int i = 0;
srand(time(NULL));
while (i < 3)
{
printf("%d", i);
q = malloc(sizeof(liste));
if (*LBO == NULL)
{
q->adresse = 0;
q->taille = random(5, 45);
q->temp = random(5, 15);
q->suivant = *LBO;
*LBO = q;
i++;
}
else
{
prec = *LBO;
q->taille = random(5, 45);
q->temp = random(5, 15);
q->adresse = prec->adresse + prec->taille;
q->suivant = *LBO;
*LBO = q;
i++;
}
}
}
void affichage(liste LBO)
{
printf("\nvoici ta liste \n ");
while (LBO != NULL)
{
printf("%d-->", LBO->taille);
LBO = LBO->suivant;
}
if (LBO == NULL)
printf("NULL");
}
int main()
{
// or here
printf("Hello world!\n");
liste LBO;
initialisation(&LBO);
creation(&LBO);
affichage(LBO);
return 0;
}

There are several issues:
Instead of calling
initialisation(&LBO);
which is not really wrong, just write:
LBO = NULL;
Then don't hide pointers with typedefs, it only adds confusion.
Instead of:
typedef struct noeud
{
int adresse, taille, temp;
struct noeud* suivant;
} *liste;
Write:
struct noeud
{
int adresse, taille, temp;
struct noeud* suivant;
};
and use struct noeud* instead of liste.
Now the real problem:
This is wrong. Here you allocate the size for a pointer, but you need to allocate the size for the whole structure:
q = malloc(sizeof(liste));
which is actually the same as:
q = malloc(sizeof(struct noeud*))
but you need:
q = malloc(sizeof(struct noeud))
You see now why hiding pointers with typedefs is a bad idea.
So here is the corrected version of your program (#includes ommitted for brevity):
struct noeud
{
int adresse, taille, temp;
struct noeud* suivant;
};
int random(int a, int b)
{
return (a + (rand() % ((b + 1) + a)));
}
void creation(struct noeud** LBO)
{
struct noeud* q, *prec = NULL;
int i = 0;
// srand(time(NULL)); <<<<< don't call srand here, call it once at the
// beginning of the program
while (i < 3)
{
printf("%d", i);
q = malloc(sizeof(struct noeud));
if (*LBO == NULL)
{
q->adresse = 0;
q->taille = random(5, 45);
q->temp = random(5, 15);
q->suivant = *LBO;
*LBO = q;
i++;
}
else
{
prec = *LBO;
q->taille = random(5, 45);
q->temp = random(5, 15);
q->adresse = prec->adresse + prec->taille;
q->suivant = *LBO;
*LBO = q;
i++;
}
}
}
void affichage(struct noeud* LBO)
{
printf("\nvoici ta struct noeud* \n ");
while (LBO != NULL)
{
printf("%d-->", LBO->taille);
LBO = LBO->suivant;
}
// if (LBO == NULL) <<<<<<<<<<< drop this, LBO is always NULL here
// but it doesn't hurt, it's just useless
printf("NULL");
}
int main()
{
srand(time(NULL)); // <<<<<<<<<<<<< call srand here
struct noeud* LBO;
LBO = NULL;
creation(&LBO);
affichage(LBO);
return 0;
}
There is still room for improvement, especially the creation function is somewhat awkward.
Also look at the comments with <<<<<<<<<<<, there are minor corrections

Adjacency list and struct Dijkstra

I must create a Dijkstra algorithm program using an adjacency list. My teacher give me this struct.
But I have this error :
note: expected 'struct maillon **' but argument is of type 'LISTE'
void insere(int som_a, int som_b, int poids, LISTE Adj[]){
Where the argument nom is vertices, poids is weight, som_a and som_b are vertices.
function void insere : insert (som_b, poids) At the top of the adjacency list Adj[som_a]
typedef struct maillon{
struct maillon *suiv;
int nom;
int poids;
} MAILLON, *LISTE;
void insere(int som_a, int som_b, int poids, LISTE Adj[]) {
LISTE prem = malloc(sizeof(LISTE));
prem->nom = som_b;
prem->poids = poids;
prem->suiv = Adj[som_a];
Adj[som_a] = prem;
}
void dijsktra(int s, GRAPHE G) {
int i, j, dist[NB_SOM_MAX], INT_MAX = 0, pred[NB_SOM_MAX], min, nb = 0, nbmin = 0;
LISTE S,F = G.Adj;
for(i = 0; i < G.nbSommets; i++) {
dist[i] = INT_MAX;
pred[i] = NULL;
}
dist[0] = 0;
S = NULL;
while(F != NULL){
min = G.Adj[0]->poids;
for(i = 1; i < G.nbSommets; i++) {
if(min > G.Adj[i]->poids) {
min = G.Adj[i]->poids;
nbmin = i;
}
}
insere(nb, nbmin, min, S);
nb++;
if(nbmin == 0){
F = F->suiv;
}
else{ // F[nbmin-1]->suiv = F[nbmin + 1];
F[nbmin - 1] = F[nbmin + 1];
}
for(i = G.Adj[nbmin]->nom; i < G.nbSommets; i++){
if(dist[i] > dist[nbmin] + G.Adj[nbmin]->poids){
dist[i] = dist[nbmin] + G.Adj[nbmin]->poids;
pred[i] = nbmin;
}
}
}
for(i = 0; i < G.nbSommets; i++){
printf("Chemin optimal de %d à %d : ", i, s);
printf("%d-", i);
j = i;
while(pred[j] != s || pred[j] != NULL){
printf("%d-", pred[j]);
j = pred[j];
}
printf("\n");
}
}

Finding one Hamiltonian cycle in graph error

I have a program in C which reads definition of graph from file, search for Hamiltonian cycle (only one) and prints it on screen if found. Problem is that program is crashing when I'm trying to find cycle in graphs with 30 and more vertices (for 30 vertices it sometimes shows cycle end get crashed (with different saturations), for more get crashed instantly). When I try to debug it stops at free() function and shows SIGTRAP signal. What can I do to fix that? Here's my code:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
typedef struct Lista
{
struct Lista * next;
int v;
} Lista;
Lista * stos;
bool *visited;
int wierzcholki, krawedzie;
int *S;
int sptr;
Lista **graf;
bool czyZnaleziono = false;
int DFSHamilton(int v)
{
if (!czyZnaleziono)
{
int i;
bool test;
Lista *p;
S[sptr++] = v;
if(sptr < wierzcholki)
{
visited[v] = true;
for(p = graf[v]; p; p = p->next)
if(!visited[p->v]) DFSHamilton(p->v);
visited[v] = false;
}
else
{
test = false;
for(p = graf[v]; p; p = p->next)
if(!(p->v))
{
test = true;
break;
}
if(test)
{
printf("Hamiltonian Cycle : ");
for(i = 0; i < sptr; i++)
{
printf("%d ",S[i]);
}
printf("0\n");
czyZnaleziono = true;
}
}
sptr--;
}
}
int main()
{
FILE *plik;
Lista *p, *r;
plik = fopen("rzeczy40-95.txt", "r");
double start, stop, czas;
int i, j, w1, w2;
sptr = 0;
visited = malloc(krawedzie*sizeof(bool));
if (plik == NULL)
{
printf("Nie mozna odnalezc pliku");
return 0;
}
else
{
fscanf(plik, "%d %d", &wierzcholki, &krawedzie);
S = malloc(wierzcholki*sizeof(int));
graf = malloc(wierzcholki*sizeof(Lista));
for(i=0; i<wierzcholki; i++)
{
graf[i] = NULL;
visited[i] = false;
}
for(j=0; j<krawedzie; j++)
{
fscanf(plik,"%d %d", &w1, &w2);
p = malloc(sizeof(Lista));
r = malloc(sizeof(Lista));
p->v = w2;
p->next = graf[w1];
graf[w1] = p;
r->v = w1;
r->next = graf[w2];
graf[w2] = r;
}
fclose(plik);
DFSHamilton(0);
free(visited);
free(S);
for (i = 0; i < wierzcholki; i++)
{
free(graf[i]);
}
free(graf);
return 0;
}
}

Assignment from incompatible pointer type in Eclipse

I have seen many questions on this topic, but couldn't take much sense from them and couldn't compare it to my code. I'm not sure what I'm doing wrong, but it appears as a warning on Eclipse, and I think it might be what's making my function behave differently than it should.
The comments and variables are in portuguese, so if you need me to translate any part of it, or to tell you what each function should do, just tell me.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "grafo.h"
typedef struct _relemento
{
/** string armazenada */
char *nome;
int x, y, id;
struct _elemento *proximo;
} robot_lista;
typedef struct
{
robot_lista *raiz;
int tamanho;
} listarobots;
typedef struct _elemento
{
/** string armazenada */
int x;
int y;
int v;
struct _elemento *proximo;
} elemento_lista;
typedef struct
{
elemento_lista *raiz;
int tamanho;
} lista;
listarobots* listarobots_nova()
{
/* cria lista */
listarobots *lst = (listarobots*) malloc(sizeof(listarobots));
if(lst == NULL)
return NULL;
/* lista esta' vazia */
lst->raiz = NULL;
lst->tamanho = 0;
return lst;
}
robot_lista* novorobot_str(const char* valor, int x, int y, int id)
{
/* aloca memoria para a estrutura lista */
robot_lista *item = (robot_lista *) malloc(sizeof(robot_lista));
if(item == NULL)
return NULL;
/* aloca memoria para string */
item->nome = (char *) malloc((strlen(valor)+1)*sizeof(char));
if(item->nome == NULL)
{
free(item);
return NULL;
}
/* copia valor */
strcpy(item->nome, valor);
item->x=x;
item->y=y;
item->id=id;
/* item ainda nao tem proximo */
item->proximo = NULL;
return item;
}
int listarobots_insere(listarobots *lst, const char* valor, int x, int y,int id)
{
robot_lista *curr = NULL, *temp;
if (lst == NULL)
return -1;
temp = lst->raiz;
/* cria novo item */
curr = novorobot_str(valor, x, y, id);
if (curr == NULL)
return -1;
lst->tamanho++;
curr->proximo = temp;
lst->raiz = curr;
return 1;
}
int listarobot_pesquisa(listarobots *lst, const char* str, int* x, int* y, int *id)
{
int i=0;
robot_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if (strcmp((aux->nome), str) == 0)
{
*x= aux->x;
*y= aux->y;
*id= aux->id;
return i;
}
}
return -1;
}
int listarobot_atribui(listarobots *lst, int pos, int x, int y)
{
int i=0;
robot_lista *aux;
if (lst == NULL || pos < 0)
return -1;
aux = lst->raiz;
/* procura item na posicao pos */
for (i = 0; i < pos && aux != NULL; i++)
aux = aux->proximo;
/* se aux e' NULL entao nao existe posicao pos */
if (aux == NULL)
return -1;
aux->x=x;
aux->y=y;
return pos;
}
lista* lista_nova()
{
/* cria lista */
lista *lst = (lista*) malloc(sizeof(lista));
if(lst == NULL)
return NULL;
/* lista esta' vazia */
lst->raiz = NULL;
lst->tamanho = 0;
return lst;
}
elemento_lista* novo_str(int x, int y, int v)
{
/* aloca memoria para a estrutura lista */
elemento_lista *item = (elemento_lista *) malloc(sizeof(elemento_lista));
if(item == NULL)
return NULL;
item->v=v;
item->x=x;
item->y=y;
/* item ainda nao tem proximo */
item->proximo = NULL;
return item;
}
int lista_insere(lista *lst, int x, int y, int v)
{
elemento_lista *curr = NULL, *temp;
if (lst == NULL)
return -1;
temp = lst->raiz;
/* cria novo item */
curr = novo_str(x,y,v);
if (curr == NULL)
return -1;
lst->tamanho++;
curr->proximo = temp;
lst->raiz = curr;
return v;
}
int lista_pesquisa(lista *lst, int x, int y)
{
int i=0;
elemento_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if ((aux->x==x) && (aux->y==y))
{
return aux->v;
}
}
return -1;
}
int lista_xy (lista *lst, int v, int *x , int* y)
{
int i=0;
elemento_lista *aux;
if(lst == NULL)
return -1;
/* pesquisa sequencial */
for (aux = lst->raiz; aux != NULL; aux = aux->proximo, i++)
{
if ((aux->v==v))
{
*x=aux->x;
*y=aux->y;
return 1;
}
}
return -1;
}
void leitura(int *tamx,int *tamy,int *xminfinal, int* yminfinal, int *wx, int *wy, int *fimx, int *fimy, FILE * fp, grafo *robots, lista *celulas, listarobots *posicoes)
{
int naofaznada,tamanho=0, i, x, y, xmax, xmin, ymax, ymin, v=1,dest,poslst, origem,id=0;
char nome[16], aux;
xmax=xmin=ymax=ymin=0;
celulas=lista_nova();
lista_insere(celulas, 0,0,0);
fp = fopen("input.txt", "r");
robots = grafo_novo(tamanho,NAODIRECIONADO);
posicoes=listarobots_nova();
fscanf( fp, " %c", &aux);
while (aux!=EOF)
{
for (i=0;aux!= ',';i++)
{
nome[i]=aux;
nome[i+1]='\0';
fscanf(fp, " %c", &aux);
}
fscanf(fp, " %c", &aux);
poslst=listarobot_pesquisa(posicoes, nome, &x, &y, &naofaznada);
if(poslst==-1)
{
if(aux=='D')
{
x=0;
y=-1;
}
if(aux=='U')
{
x=0;
y=1;
}
if(aux=='L')
{
x=-1;
y=0;
}
if(aux=='R')
{
x=1;
y=0;
}
listarobots_insere(posicoes, nome, x, y, id);
id++;
origem=0;
if(x>xmax) xmax=x;
if(x<xmin) xmin=x;
if(y>ymax) ymax=y;
if(y<ymin) ymin=y;
if(lista_pesquisa(celulas, x, y)==-1)
{
lista_insere(celulas, x, y, v);
dest=v;
v++;
grafo_adiciona(robots, 0, dest);
if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
}
}
else
{
origem=lista_pesquisa(celulas,x, y);
if(aux=='D')
{
y=y-1;
}
if(aux=='U')
{
y=y+1;
}
if(aux=='L')
{
x=x-1;
}
if(aux=='R')
{
x=x+1;
}
listarobot_atribui(posicoes, poslst, x, y);
}
if(x>xmax) xmax=x;
if(x<xmin) xmin=x;
if(y>ymax) ymax=y;
if(y<ymin) ymin=y;
if(lista_pesquisa(celulas, x, y)==-1)
{
lista_insere(celulas, x, y, v);
dest=v;
v++;
grafo_adiciona(robots, origem, dest);
if(lista_pesquisa(celulas, (x+1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x+1), y));
if(lista_pesquisa(celulas, (x-1),y)!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, (x-1), y));
if(lista_pesquisa(celulas, x,(y+1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y+1)));
if(lista_pesquisa(celulas, x,(y-1))!=-1) grafo_adiciona(robots, dest, lista_pesquisa(celulas, x, (y-1)));
}
if(fscanf(fp, " %c", &aux)==EOF) break;
if(aux=='?')
{
*wx=x;
*wy=y;
if(fscanf(fp, " %c", &aux)==EOF) break;
}
if(aux=='!')
{
*fimx=x;
*fimy=y;
if(fscanf(fp, " %c", &aux)==EOF) break;
}
}
*tamx= xmax-xmin+1;
*tamy= ymax-ymin +1;
*xminfinal=xmin;
*yminfinal=ymin;
return ;
}
void mapeamento(FILE * out, int x, int y, int ymin, int xmin, int wx, int wy, int fimx, int fimy, lista* celulas )
{
int xatual, yatual;
for(yatual=ymin+ y-1; yatual!=ymin-1;yatual--)
{
for(xatual=xmin; xatual!=xmin+x; xatual++)
{
if((xatual==0) && (yatual==0)) fprintf(out," e ");
else if((xatual==wx)&&(yatual==wy)) fprintf(out, " w ");
else if((xatual==fimx)&&(yatual==fimy)) fprintf(out, " s ");
else if(lista_pesquisa(celulas, x, y)==-1) fprintf(out, " * ");
else if(lista_pesquisa(celulas, x, y)!=-1)fprintf(out, " . ");
if(xatual==fimx) fprintf(out, "\n");
}
}
return;
}
void caminhos(int wx, int wy, int fimx, int fimy, lista* celulas, FILE *fp, FILE *out, grafo *robots, listarobots* posicoes)
{
int restantes,nfnx,nfny,i,id,is,antx,anty,novox,novoy,tamanhocaminho1,tamanhocaminho2, *caminho1, *caminho2, *posrobots;
char *caminho,nome[16], aux;
caminho1=grafo_bfs(robots, 0, lista_pesquisa(celulas, wx, wy), &tamanhocaminho1);
caminho2=grafo_bfs(robots, lista_pesquisa(celulas, wx, wy), lista_pesquisa(celulas, fimx, fimy), &tamanhocaminho2);
caminho= malloc((tamanhocaminho1+tamanhocaminho2)*sizeof(char));
antx=0;
anty=0;
is=0;
for(i=1; i<tamanhocaminho1; i++, is++)
{
lista_xy(celulas, caminho1[i], &novox, &novoy);
if((novox-antx)==1) caminho[is]= 'R';
else if((novox-antx)==-1) caminho[is]= 'L';
else if((novoy-anty)==-1) caminho[is]= 'D';
else if((novoy-anty)==1) caminho[is]= 'U';
antx=novox;
anty=novoy;
}
for(i=1; i<tamanhocaminho2; i++, is++)
{
lista_xy(celulas, caminho1[i], &novox, &novoy);
if((novox-antx)==1) caminho[is]= 'R';
else if((novox-antx)==-1) caminho[is]= 'L';
else if((novoy-anty)==-1) caminho[is]= 'D';
else if((novoy-anty)==1) caminho[is]= 'U';
antx=novox;
anty=novoy;
}
caminho[is]='\0';
fprintf(out, "\n\n%s\n", caminho);
free(caminho1);
free(caminho2);
fclose(fp);
fp=fopen("input.txt", "r");
restantes=posicoes->tamanho;
posrobots=calloc (posicoes->tamanho, sizeof(int));
fscanf(fp, " %c", &aux);
while (aux!=EOF)
{
for (i=0;aux!= ',';i++)
{
nome[i]=aux;
nome[i+1]='\0';
fscanf(fp, " %c", &aux);
}
fscanf(fp, " %c", &aux);
listarobot_pesquisa(posicoes, nome, &nfnx, &nfny, &id);
if(posrobots[id]==-1) nfnx=1;
else if(caminho[posrobots[id]]==aux) posrobots[id]++;
else
{
posrobots[id]=-1;
restantes--;
}
if(posrobots[id]==is) fprintf(out, "%s\n", nome);
fscanf(fp, " %c", &aux);
if(aux=='?')
{
fscanf(fp, " %c", &aux);
}
if(aux=='!')
{
fscanf(fp, " %c", &aux);
}
}
if(restantes==0) fprintf(out, "0\n");
}
void output()
{
}
int main()
{
FILE *fp, *out;
grafo *robots;
lista *celulas;
listarobots *posicoes;
celulas=(lista * )malloc(sizeof(lista));
robots=(grafo * )malloc(sizeof(grafo));
posicoes=(listarobots * )malloc(sizeof(listarobots));
fp=(FILE * )malloc(sizeof(FILE));
out=(FILE * )malloc(sizeof(FILE));
int x,y,xmin, ymin,wx,wy,fimx,fimy;
out=fopen("output.txt", "w");
leitura(&x, &y, &xmin, &ymin,&wx, &wy, &fimx, &fimy, fp, robots, celulas, posicoes);
fprintf(out,"largura:%d, altura:%d\n", x, y );
mapeamento(out, x, y, ymin, xmin, wx, wy, fimx, fimy, celulas);
//caminhos(wx, wy,fimx, fimy,celulas, fp, out, robots, posicoes);
return 0;
}
the extra includes dont make a difference, I've checked and the errors are on this block of code, but just in case, I'll post here the code for the include "grafo.h"
#include <stdio.h>
#include <stdlib.h>
#include "grafo.h"
/* cria no da lista de adjacencias */
lista_no* cria_no(int v)
{
lista_no* novo = (lista_no*)malloc(sizeof(lista_no));
if(!novo)
return NULL;
novo->vertice = v;
novo->proximo = NULL;
return novo;
}
/* cria grafo com n vertices */
grafo* grafo_novo(int n, tipo_grafo tipo)
{
grafo* g = (grafo*)malloc(sizeof(grafo));
lista_no novo;
if(g == NULL)
return NULL;
g->tamanho = 1;
g->tipo = tipo;
/* cria array de listas de adjacencias */
g->adjacencias = (lista_adj*)calloc(n, sizeof(lista_adj));
if(g->adjacencias == NULL)
{
free(g);
return NULL;
}
g->adjacencias[0].inicio=NULL;
return g;
}
/* apaga grafo e liberta memoria */
void grafo_apaga(grafo* g)
{
if(g == NULL)
return;
if(g->adjacencias != NULL)
{
int v;
for (v = 0; v < g->tamanho; v++)
{
while (g->adjacencias[v].inicio)
{
lista_no* aux = g->adjacencias[v].inicio;
g->adjacencias[v].inicio = g->adjacencias[v].inicio->proximo;
free(aux);
}
}
free(g->adjacencias);
}
free(g);
}
/* adiciona uma aresta ao grafo*/
void grafo_adiciona(grafo *g, int origem, int dest)
{
lista_no* novo,*aux,*ant;
if (g == NULL || grafo_existe(g, origem, dest))
return;
/* adiciona uma aresta de origem para dest na lista de adjacencias */
novo = cria_no(dest);
novo->proximo = NULL;
g->adjacencias = (lista_adj*)realloc(g->adjacencias, (g->tamanho+1)*sizeof(lista_adj));
g->adjacencias[dest].inicio=NULL;
g->tamanho++;
ant= aux =g->adjacencias[origem].inicio;
if(ant==NULL) g->adjacencias[origem].inicio=novo;
else
{
aux=ant->proximo;
while(aux!=NULL)
{
ant=aux;
aux=ant->proximo;
}
ant->proximo=novo;
}
g->adjacencias[origem].tamanho++;
if(g->tipo == NAODIRECIONADO)
{
/* adiciona tambem aresta de dest para origem */
novo = cria_no(origem);
novo->proximo = NULL;
ant= aux =g->adjacencias[dest].inicio;
if(ant==NULL) g->adjacencias[dest].inicio=novo;
else
{
aux=ant->proximo;
while(aux!=NULL)
{
ant=aux;
aux=ant->proximo;
}
ant->proximo=novo;
}
g->adjacencias[dest].tamanho++;
}
}
/* remove uma aresta do grafo*/
void grafo_remove(grafo *g, int origem, int dest)
{
lista_no *aux, *prev;
if (g == NULL || g->adjacencias[origem].inicio == NULL)
return;
aux = g->adjacencias[origem].inicio;
/* caso especial: primeiro no' da lista */
if(aux->vertice == dest)
{
g->adjacencias[origem].inicio = aux->proximo;
free(aux);
}
else
{
prev = aux;
aux = aux->proximo;
while(aux != NULL)
{
if(aux->vertice == dest)
{
prev->proximo = aux->proximo;
free(aux);
break;
}
prev = aux;
aux = aux->proximo;
}
}
if(g->tipo == NAODIRECIONADO)
{
/* remove tambem aresta de dest para origem */
/* caso especial: primeiro no' da lista */
aux = g->adjacencias[dest].inicio;
if(aux->vertice == origem)
{
g->adjacencias[dest].inicio = aux->proximo;
free(aux);
}
else
{
prev = aux;
aux = aux->proximo;
while(aux != NULL)
{
if(aux->vertice == origem)
{
prev->proximo = aux->proximo;
free(aux);
break;
}
prev = aux;
aux = aux->proximo;
}
}
}
}
/* verifica se existe uma aresta entre os vertices origem e dest */
int grafo_existe(grafo *g, int origem, int dest)
{
if (g == NULL)
return 0;
lista_no* aux = g->adjacencias[origem].inicio;
while (aux)
{
if(aux->vertice == dest)
return 1;
aux = aux->proximo;
}
return 0;
}
/* imprime as listas de adjacencias do grafo */
void grafo_imprime(grafo* g)
{
int i;
for (i = 0; i < g->tamanho; i++)
{
lista_no* aux = g->adjacencias[i].inicio;
printf("%d: ", i);
if(aux)
{
printf("%d", aux->vertice);
aux = aux->proximo;
while (aux)
{
printf("->%d", aux->vertice);
aux = aux->proximo;
}
}
printf("\n");
}
}
int dfs_helper(grafo *g, int inicio, int fim, int profundidade, int *visitados)
{
int i, d;
if(visitados[inicio])
return 0;
visitados[inicio] = profundidade;
if(inicio == fim)
return profundidade;
for(i=0; i < g->tamanho; i++)
{
if(grafo_existe(g, inicio, i))
{
d = dfs_helper(g, i, fim, profundidade + 1, visitados);
if(d)
return d;
}
}
visitados[inicio] = 0;
return 0;
}
/* retorna caminho entre origem e dest usando depth-first search (DFS)
n guarda o tamanho do caminho
nao garante caminho mais curto */
int* grafo_dfs(grafo *g, int inicio, int fim, int *n)
{
int *visitados, *caminho;
int profundidade, i, ret_i;
if(g==NULL)
return 0;
visitados = calloc(g->tamanho, sizeof(int));
profundidade = dfs_helper(g, inicio, fim, 1, visitados);
if(profundidade == 0)
{
free(visitados);
*n=0;
return NULL;
}
/* reconstrucao do caminho */
caminho = calloc(profundidade, sizeof(int));
for (ret_i = 0; ret_i < profundidade; ret_i++)
for (i = 0; i< g->tamanho; i++)
if(visitados[i] == ret_i + 1)
{
caminho[ret_i] = i;
break;
}
*n = profundidade;
free(visitados);
return caminho;
}
/* retorna caminho entre origem e dest usando breadth-first search (BFS)
n guarda o tamanho do caminho
garante caminho mais curto */
int* grafo_bfs(grafo *g, int inicio, int fim, int *n)
{
int *caminho, *visitados, *fila;
int profundidade, i, j, fila_inicio = 0, fila_fim=0;
if(g==NULL)
return 0;
visitados = calloc(g->tamanho, sizeof(int));
fila = calloc(g->tamanho, sizeof(int));
for(i = 0; i < g->tamanho; i++)
visitados[i] = -1;
visitados[inicio] = inicio;
fila[fila_fim++] = inicio;
while(fila_inicio != fila_fim)
{
i = fila[fila_inicio];
fila_inicio = (fila_inicio + 1) % g->tamanho;
for(j = 0; j < g->tamanho; j++)
if(grafo_existe(g, i, j) && visitados[j] == -1)
{
visitados[j] = i;
fila[fila_fim] = j;
fila_fim = (fila_fim + 1) % g->tamanho;
}
}
/* reconstrucao do caminho */
profundidade = 0;
if(visitados[fim] >= 0)
{
int tmp = fim;
profundidade = 1;
while(visitados[tmp] != tmp)
{
profundidade++;
tmp = visitados[tmp];
}
caminho = malloc(profundidade * sizeof(int));
tmp = fim;
i = 0;
while(i++ < profundidade)
{
caminho[profundidade - i] = tmp;
tmp = visitados[tmp];
}
}
free(fila);
free(visitados);
*n=profundidade;
return caminho;
}
And the warnings are:
Description Resource Path Location Type
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 110 C/C++ Problem
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 135 C/C++ Problem
assignment from incompatible pointer type [enabled by default] trabalho.c /trabalho/src line 95 C/C++ Problem
I appreciate any and all the help you can offer. I am still pretty new at programming and this warnings are completely messing with my mind.

It looks like you're assigning proximo (which are pointers to _elemento) to variables that are pointers to robot_lista.

Resources