Merge branch 'grafo' into develop

Conflicts:
	Makefile
	main.c

Makefile

@@ -10,9 +10,10 @@ test: main
 	chmod +x runTests.sh; \
 	./runTests.sh
 
-main: main.c libs/jogador.o libs/tabuleiro.o libs/filha.o
+main: main.c libs/tabuleiro.o libs/grafo.o libs/vertice.o libs/filha.o libs/lista.o libs/no.o
 	$(CC) $(CFLAGS) -o $@ $^
 
 clean:
 	$(RM) *.o
+	$(RM) libs/*.o
 	$(RM) tests/*.in

libs/filha.c

-#include "filha.h"
 #include <stdbool.h>
 #include <stdlib.h>
-
-struct No {
-    void *conteudo;
-    No anterior, proximo;
-};
+#include "filha.h"
+#include "no.h"
 
 struct Filha {
     unsigned int tamanho;
@@ -24,58 +20,46 @@ unsigned int tamanhoFilha(Filha f) {
     return f->tamanho;
 }
 
-No primeiroNo(Filha f) {
+No primeiroNoFilha(Filha f) {
     if(f->tamanho == 0) {
         return NULL;
     }
     No n = f->primeiro;
-    f->primeiro = f->primeiro->proximo;
-    n->anterior = NULL;
-    n->proximo = NULL;
+    f->primeiro = getSucessorNo(f->primeiro);
+    setSucessorNo(n, NULL);
+    setAntecessorNo(n, NULL);
     return n;
 }
 
-No ultimoNo(Filha f) {
+No ultimoNoFilha(Filha f) {
     if(f->tamanho == 0) {
         return NULL;
     }
     No n = f->ultimo;
-    f->ultimo = f->ultimo->anterior;
-    n->anterior = NULL;
-    n->proximo = NULL;
+    f->ultimo = getAntecessorNo(f->ultimo);
+    setSucessorNo(n, NULL);
+    setAntecessorNo(n, NULL);
     return n;
 }
 
-No sucessorNo(No n) {
-    return n->proximo;
-}
-
-No antecessorNo(No n) {
-    return n->anterior;
-}
-
-void *conteudo(No n) {
-    return n->conteudo;
-}
-
-No insere(void *conteudo, Filha f) {
-    No novo = malloc(sizeof(struct No));
+No insereFilha(void *conteudo, Filha f) {
+    No novo = criaNo();
 
     if(!novo) return NULL;
 
-    novo->conteudo = conteudo;
-    novo->anterior = f->ultimo;
+    setConteudo(novo, conteudo);
+    setAntecessorNo(novo, f->ultimo);
     ++f->tamanho;
     return f->ultimo = novo;
 }
 
-bool destroi(Filha f, bool destroi(void *)) {
+bool destroiFilha(Filha f, bool destroi(void *)) {
     No n;
     bool ok=true;
 
-    while( (n = primeiroNo(f)) ) {
+    while( (n = primeiroNoFilha(f)) ) {
         if(destroi)
-            ok &= destroi(conteudo(n));
+            ok &= destroi(getConteudo(n));
         free(n);
     }
     free(f);

libs/filha.h

 #ifndef _FILHA_
 #define _FILHA_
 #include <stdbool.h>
+#include "no.h"
 
 // Filha é uma estrutura que pode ser vista como Fila ou Pilha
 typedef struct Filha *Filha;
@@ -16,24 +17,15 @@ Filha constroiFilha();
 unsigned int tamanhoFilha(Filha f);
 
 // Remove o primeiro nó da filha f ou retorna NULL se f for vazia
-No primeiroNo(Filha f);
+No primeiroNoFilha(Filha f);
 
 // Remove o último nó da filha f ou retorna NULL se f for vazia
-No ultimoNo(Filha f);
-
-// Devolve o nó sucessor de n ou NULL se n é o último nó da filha
-No sucessorNo(No n);
-
-// Devolve o nó antecessor de n ou NULL se n é o primeiro nó da filha
-No antecessorNo(No n);
-
-// Devolve o conteúdo de n
-void *conteudo(No n);
+No ultimoNoFilha(Filha f);
 
 // Insere um novo nó no fim da Filha f
 //
 // Devolve o nó recém criado ou NULL em caso de falha
-No insere(void *conteudo, Filha f);
+No insereFilha(void *conteudo, Filha f);
 
 // Desaloca a filha f e todos os seus nós
 //
@@ -42,7 +34,7 @@ No insere(void *conteudo, Filha f);
 // para cada nó n da filha
 //
 // devolve true em caso de sucesso ou false em caso de falha
-bool destroi(Filha f, bool destroi(void *));
+bool destroiFilha(Filha f, bool destroi(void *));
 
 // Impreme todos os nós da filha f
 //

libs/grafo.c

+#include <stdlib.h>
+#include "grafo.h"
+#include "lista.h"
+#include "vertice.h"
+#include "tabuleiro.h"
+
+struct Grafo {
+    Lista vertices;
+};
+
+Grafo criaGrafo() {
+    Grafo g = malloc(sizeof(struct Grafo));
+
+    g->vertices = constroiLista();
+    return g;
+}
+
+Vertice insereVertice(Grafo g, Vertice v) {
+    if(insereLista(v, g->vertices)) {
+        return v;
+    }
+    return NULL;
+}
+
+void criaArco(Vertice v, Vertice w) {
+    insereLista(w, v->filhos);
+    insereLista(v, w->pais);
+}
+
+void tabuleiroParaGrafo(Tblr t, Grafo g) {
+    for(int i=0; i < t->x; ++i) {
+        for(int j=0; j < t->y; ++j) {
+            Celula c = t->celulas[i * t->y + j];
+            Vertice v = NULL;
+            if(c->vert == NULL) {
+                v = criaVertice();
+                v->cor = c->cor;
+                v->peso = 1;
+                c->vert = v;
+                insereVertice(g, v);
+            } else {
+                v = c->vert;
+            }
+            //------Vizinhos
+            Celula cima, baixo, esq, dir;
+            // Cima
+            if(i > 0) {
+                cima = t->celulas[(i-1) * t->y + j];
+                if(cima->vert == NULL) {
+                    Vertice w = criaVertice();
+                    w->cor = cima->cor;
+                    w->peso = 1;
+                    c->vert = w;
+                    insereVertice(g, w);
+                    criaArco(v, w);
+                    criaArco(w, v);
+                }
+            }
+            // Direita
+            if(j < t->y - 1) {
+                dir = t->celulas[i * t->y + (j + 1)];
+                if(dir->vert == NULL) {
+                    Vertice w = criaVertice();
+                    w->cor = dir->cor;
+                    w->peso = 1;
+                    c->vert = w;
+                    insereVertice(g, w);
+                    criaArco(v, w);
+                    criaArco(w, v);
+                }
+            }
+            // Baixo
+            if(i < t->x - 1) {
+                baixo = t->celulas[(i + 1) * t->y + j];
+                if(baixo->vert == NULL) {
+                    Vertice w = criaVertice();
+                    w->cor = baixo->cor;
+                    w->peso = 1;
+                    c->vert = w;
+                    insereVertice(g, w);
+                    criaArco(v, w);
+                    criaArco(w, v);
+                }
+            }
+            // Esquerda
+            if(j > 0) {
+                esq = t->celulas[i * t->y + (j - 1)];
+                if(esq->vert == NULL) {
+                    Vertice w = criaVertice();
+                    w->cor = esq->cor;
+                    w->peso = 1;
+                    c->vert = w;
+                    insereVertice(g, w);
+                    criaArco(v, w);
+                    criaArco(w, v);
+                }
+            }
+        }
+    }
+    return;
+}
+
+void agrupaGrafo(Grafo g) {
+    return;
+}
+
+int *buscaCaminho(Grafo g) {
+    int *caminho = malloc(sizeof(int));
+    return caminho;
+}

libs/grafo.h

+#ifndef _GRAFO_
+#define _GRAFO_
+#include "tabuleiro.h"
+
+typedef struct Grafo *Grafo;
+
+Grafo criaGrafo();
+
+Vertice insereVertice(Grafo g, Vertice v);
+
+void criaArco(Vertice v, Vertice w);
+
+void tabuleiroParaGrafo(Tblr t, Grafo g);
+
+void agrupaGrafo(Grafo g);
+
+int *buscaCaminho(Grafo g);
+
+#endif

libs/lista.c

+#include <malloc.h>
+#include "lista.h"
+#include "no.h"
+//---------------------------------------------------------------------------
+// Lista encadeada
+
+struct Lista {
+
+    unsigned int tamanho;
+    int padding; // só pra evitar warning
+    No primeiro;
+};
+//---------------------------------------------------------------------------
+// devolve o número de nós da Lista l
+
+unsigned int tamanhoLista(Lista l) { return l->tamanho; }
+
+//---------------------------------------------------------------------------
+// devolve o primeiro nó da Lista l,
+//      ou NULL, se l é vazia
+
+No primeiroNoLista(Lista l) { return l->primeiro; }
+
+//---------------------------------------------------------------------------
+// cria uma Lista vazia e a devolve
+//
+// devolve NULL em caso de falha
+
+Lista constroiLista(void) {
+
+    Lista l = malloc(sizeof(struct Lista));
+
+    if ( ! l )
+    return NULL;
+
+    l->primeiro = NULL;
+    l->tamanho = 0;
+
+    return l;
+}
+//---------------------------------------------------------------------------
+// desaloca a Lista l e todos os seus nós
+//
+// se destroi != NULL invoca
+//
+//     destroi(getConteudo(n))
+//
+// para cada nó n da Lista.
+//
+// devolve 1 em caso de sucesso,
+//      ou 0 em caso de falha
+
+int destroiLista(Lista l, int destroi(void *)) {
+
+    No p;
+    int ok=1;
+
+    while ( (p = primeiroNoLista(l)) ) {
+
+        l->primeiro = getSucessorNo(p);
+
+        if ( destroi )
+        ok &= destroi(getConteudo(p));
+
+        free(p);
+    }
+
+    free(l);
+
+    return ok;
+}
+//---------------------------------------------------------------------------
+// insere um novo nó na Lista l cujo conteúdo é p
+//
+// devolve o No recém-criado
+//      ou NULL em caso de falha
+
+No insereLista(void *conteudo, Lista l) {
+
+    No novo = criaNo();
+
+    if ( ! novo )
+    return NULL;
+
+    setConteudo(novo, conteudo);
+    setSucessorNo(novo, primeiroNoLista(l));
+    ++l->tamanho;
+
+    return l->primeiro = novo;
+}
+
+//------------------------------------------------------------------------------
+// remove o No de endereço rNo de l
+// se destroi != NULL, executa destroi(getConteudo(rNo))
+// devolve 1, em caso de sucesso
+//         0, se rNo não for um No de l
+
+int removeNo(struct Lista *l, struct No *rNo, int destroi(void *)) {
+    int r = 1;
+    if (l->primeiro == rNo) {
+        l->primeiro = getSucessorNo(rNo);
+        if (destroi != NULL) {
+            r = destroi(getConteudo(rNo));
+        }
+        free(rNo);
+        l->tamanho--;
+        return r;
+    }
+    for (No n = primeiroNoLista(l); getSucessorNo(n); n = getSucessorNo(n)) {
+        if (getSucessorNo(n) == rNo) {
+            setSucessorNo(n, getSucessorNo(rNo));
+            if (destroi != NULL) {
+                r = destroi(getConteudo(rNo));
+            }
+            free(rNo);
+            l->tamanho--;
+            return r;
+        }
+    }
+    return 0;
+}

libs/lista.h

+#ifndef _LISTA_
+#define _LISTA_
+#include "no.h"
+
+//-----------------------------------------------------------------------------
+// (apontador para) Lista encadeada
+
+typedef struct Lista *Lista;
+
+//------------------------------------------------------------------------------
+// devolve o número de nós da Lista l
+
+unsigned int tamanhoLista(Lista l);
+
+//------------------------------------------------------------------------------
+// devolve o primeiro nó da Lista l,
+//      ou NULL, se l é vazia
+
+No primeiroNoLista(Lista l);
+
+//------------------------------------------------------------------------------
+// insere um Novo nó na Lista l cujo conteúdo é p
+//
+// devolve o No recém-criado
+//      ou NULL em caso de falha
+
+No insereLista(void *conteudo, Lista l);
+//------------------------------------------------------------------------------
+// cria uma Lista vazia e a devolve
+//
+// devolve NULL em caso de falha
+
+Lista constroiLista(void);
+//------------------------------------------------------------------------------
+// desaloca a Lista l e todos os seus nós
+//
+// se destroi != NULL invoca
+//
+//     destroi(conteudo(n))
+//
+// para cada nó n da Lista.
+//
+// devolve 1 em caso de sucesso,
+//      ou 0 em caso de falha
+
+int destroiLista(Lista l, int destroi(void *));
+
+//------------------------------------------------------------------------------
+// remove o No de endereço rNo de l
+// se destroi != NULL, executa destroi(conteudo(rNo))
+// devolve 1, em caso de sucesso
+//         0, se rNo não for um No de l
+
+int removeNoLista(struct Lista *l, struct No *rNo, int destroi(void *));
+#endif

libs/no.c

+#include <stdlib.h>
+#include "no.h"
+
+struct No {
+    void *conteudo;
+    No anterior, proximo;
+};
+
+No criaNo() {
+    No n = malloc(sizeof(struct No));
+
+    n->anterior = NULL;
+    n->proximo = NULL;
+    return n;
+}
+
+No getSucessorNo(No n) {
+    return n->proximo;
+}
+
+void setSucessorNo(No n, No p) {
+    n->proximo = p;
+}
+
+No getAntecessorNo(No n) {
+    return n->anterior;
+}
+
+void setAntecessorNo(No n, No p) {
+    n->anterior = p;
+}
+
+void *getConteudo(No n) {
+    return n->conteudo;
+}
+
+void setConteudo(No n, void *conteudo) {
+    n->conteudo = conteudo;
+}

libs/no.h

+#ifndef _NO_
+#define _NO_
+
+// Nó cujo conteúdo é um void *
+typedef struct No *No;
+
+// Cria um nó vazio e devolve
+No criaNo();
+
+// Devolve o nó sucessor de n ou NULL se n é o último nó da filha
+No getSucessorNo(No n);
+
+// Define o nó sucessor de n
+void setSucessorNo(No n, No p);
+
+// Devolve o nó antecessor de n ou NULL se n é o primeiro nó da filha
+No getAntecessorNo(No n);
+
+// Define o nó antecessor de n
+void setAntecessorNo(No n, No p);
+
+// Devolve o conteúdo de n
+void *getConteudo(No n);
+
+void setConteudo(No n, void *conteudo);
+
+#endif

libs/tabuleiro.c

@@ -2,18 +2,8 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include "tabuleiro.h"
-
-struct Celula {
-    // Cor da célula
-    int cor;
-    // Se a célula já foi visitada
-    bool visitada;
-};
-
-struct Tblr {
-    int x, y, cores;
-    Celula *celulas;
-};
+#include "vertice.h"
+#include "grafo.h"
 
 Tblr criaTblr() {
     Tblr t = malloc(sizeof(struct Tblr));
@@ -36,6 +26,7 @@ bool leTblr(Tblr t) {
             // Para acessar uma matrix [X][Y] em um vetor fazemos i*Y + j
             Celula c = malloc(sizeof(struct Celula));
             c->visitada = false;
+            c->vert = NULL;
             scanf("%d", &(c->cor));
             t->celulas[i * y + j] = c;
         }

libs/tabuleiro.h

 #ifndef _BOARD_
 #define _BOARD_
 #include <stdbool.h>
+#include "vertice.h"
+
+struct Celula {
+    // Cor da célula
+    int cor;
+    // Se a célula já foi visitada
+    bool visitada;
+    // Vertice a qual a célula foi mapeada
+    Vertice vert;
+};
 
 typedef struct Celula *Celula;
 
+struct Tblr {
+    int x, y, cores;
+    Celula *celulas;
+};
+
+
 typedef struct Tblr *Tblr;
 
 // Cria um tabuleiro vazio e retorna

libs/vertice.c

+#include <stdlib.h>
+#include "vertice.h"
+#include "lista.h"
+
+Vertice criaVertice() {
+    Vertice v = malloc(sizeof(struct Vertice));
+
+    v->cor = -1;
+    v->peso = 0;
+    Lista pais = constroiLista();
+    Lista filhos = constroiLista();
+    return v;
+}

libs/vertice.h

+#ifndef _VERTICE_
+#define _VERTICE_
+#include "lista.h"
+
+struct Vertice {
+    int cor;
+    int peso;
+    Lista pais;
+    Lista filhos;
+};
+
+typedef struct Vertice *Vertice;
+
+Vertice criaVertice();
+
+#endif

main.c

@@ -3,7 +3,6 @@
 #include <stdio.h>
 #include <time.h>
 #include "libs/tabuleiro.h"
-#include "libs/jogador.h"
 
 int main() {
     Tblr t = criaTblr();
@@ -14,16 +13,16 @@ int main() {
     }
     imprimeTblr(t);
 
-    // declara o grafo ponderado e seu primeiro nodo
-    Nodo grafo = criaGrafo(t);
-    if(grafo == NULL) {
-        puts("Erro na criacao do grafo");
-        return -1;
-    }
-    // faz o jogador jogar o jogo a partir do tabuleiro dado
-    // o retorno do jogador sera um vetor contendo os numeros referentes a menor jogada encontrada por ele
-    int *jogadas;
-    jogadas = Joga(grafo, t);
+    // // declara o grafo ponderado e seu primeiro nodo
+    // grafo = criaGrafo(t);
+    // if(grafo == NULL)) {
+    //     puts("Erro na criacao do grafo");
+    //     return -1;
+    // }
+    // // faz o jogador jogar o jogo a partir do tabuleiro dado
+    // // o retorno do jogador sera um vetor contendo os numeros referentes a menor jogada encontrada por ele
+    // int *jogadas;
+    // jogadas = Joga(grafo, t);
 
     return 0;
 }

tests/runTests.sh

@@ -4,10 +4,10 @@
 tempo_max=500
 
 # tamanhos do tabuleiro
-tams=(8 16 32 64 128 512 1024)
+tams=(4 8 16 32 64 128)
 
 # lista de cores
-cores=(4 8 16 32 64)
+cores=(2 4 8 16)
 
 #-- Cores do terminal
 RED='\033[0;31m'