laberinto corregido

typedef struct
  {
    int f,c;
  }tCasilla;
  typedef tCasilla *casilla;

  typedef struct
  {
    casilla a,b;
  }tPared;
  typedef tPared *pared;

boolean Adyacente(casilla a,casilla b)
{
  if(a->f==b->f && Abs(a->c-b->c)==1 || a->c==b->c && Abs(a->f-b->f)==1)
    return 1;
  else
    return 0;
}

Static casilla NodoCasilla(vertice v,int n)
{
  casilla c;
  c=(casilla)malloc(sizeof(tCasilla));
  if(c==NULL)
    ERROR("No hay memoria");
  c->f=v/n;
  c->c=v%n;
  return c;
}

Static vertice CasillaNodo(casilla c,int n)
{
  return c->f*n+c->c;
}

static int Abs(int a)
{
  if(a>0)
    return a;
  else
    return a*(-1);
}

static int Longitud(vertice orig, vertice i, vertice *P)
{
  if (P[i] == orig)
    return 0;
  else
    return 1+Longitud(orig, P[i], P);
}

casilla CrearCasilla(vertice a,vertice b)
{
  casilla C;
  C=(casilla)malloc(sizeof(tCasilla));
  if(C==NULL)
    ERROR("CrearCasilla: No Hay memoria");
  C->f=a;
  C->c=b;
  return C;
}

pared CrearParedes(casilla a,casilla b)
{
  pared p;
  p=(pared)malloc(2*N*sizeof(tPared));
  if(p==NULL)
    ERROR("CrearPared: No Hay memoria");
  p->a=a
  p->b=b;
  return p;
}

int Laberinto(int n,pared p,casilla E,casilla S)
{
  int i,j,k,HayPared=0;
  int long_cam=0;
  tCoste **D;
  vertice **P;
  Grafo G;
  G=CrearGrafo(n*n);

  for(i=0;i<n*n;i++)
  {
    for(j=0;j<n*n;j++)
    {
      for(k=0;k<2*n*n;k++)
        if(casillaTonodo(p->a)==i && (casillaTonodo(p->b)==j ||
           casillaTonodo(p->a)==j && (casillaTonodo(p->b)==i)
            HayPared=1;
      if(Adyacente(NodoCasilla(i,n),NodoCasilla(j,n))==1 && HayPared!=1)
        InsertarGrafo(1,i,j,G);
      HayPared=0;
    }
  }
  //Mostrar matriz de costes
  for(i=0;i<n*n;i++)
  {
    for(j=0;j<n*n;j++)
      printf("G[%d][%d]=%d\n",i,j,G->Costes[i][j]);
    printf("\n");
  }

  Dijkstra(CasillaNodo(E,n),G,&D,&P);
  long_cam =(1+Longitud(CasillaNodo(E,n),CasillaNodo(S,n),P));
  Caminoi(CasillaNodo(E,n),CasillaNodo(S,n),P);

  return(long_cam);
}