Puzzle.c

#include <stdio.h>
#include <tdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/times.h>
#include "nodos.h" 
#include "estado.h"
#include "operadores.h"
#include "busqueda.h"
#include "puzzle.h"

int nFilas, nColumnas;


void tratarArgumentos(int argc, char** argv, int* pnumAlg, int* pnumHeur) 
{
  if (argc < 3)
    *pnumAlg = 1;
    *pnumHeur = 0;
  else
    *pnumAlg = atoi(argv[1]);
    *pnumHeur = atoi(argv[2]);  
}

void leerEstadosIF(estado** peinicial, estado** pefinal)
{
  int f,c;
  FILE* fich;
  estado *pe1,*pe2;
    
  /* Estado Inicial */  
  fich = fopen("inicial","r");
  fscanf(fich,"%dx%d",&nFilas,&nColumnas);
  pe1 = *peinicial = crearEstado();  
  
  for (f=0; f < nFilas; f++)  
    for (c=0; c < nColumnas; c++)
    {
      fscanf(fich,"%d",&(pe1->tablero[f][c]));
      if (pe1->tablero[f][c] == VALOR_ESPACIO_BLANCO)
      {
        pe1->filaEspacioBlanco = f;
        pe1->colEspacioBlanco = c;
      }
    }

  fclose(fich);

  /* Estado Final */
  fich = fopen("final","r");
  fscanf(fich,"%dx%d",&nFilas,&nColumnas);
  pe2 = *pefinal = crearEstado(); 
  for (f=0; f < nFilas; f++)  
    for (c=0; c < nColumnas; c++)
    {
      fscanf(fich,"%d",&(pe2-tablero[f][c]));
      if (pe2->tablero[f][c] == VALOR_ESPACIO_BLANCO)
      {
        pe2->filaEspacioBlanco = f;
        pe2->colEspacioBlanco = c;
      }
    }

  fclose(fich);     
}


void escribirPaso(movimiento m, FILE *fich)
{
  int direccion;
  
  switch (m)
  {
    case NORTE:
      direccion = 'N';      
      break;
    case SUR:
      direccion = 'S';      
      break;
    case ESTE:
      direccion = 'E';      
      break;
    case OESTE:
      direccion = 'O';      
      break;
    default:
      printf("Movimiento no valido\n");
      direccion = '?';
      break;
  }  
    
  fprintf(fich,"%c\n",direccion);      
}



int calcular(estado e)
{
  int f,c,ff,cc;
  int valor=0;
  
  for (f=0; f < nFilas; f++)
    for (c=0; c < nColumnas; c++)
      for (ff=f; ff < nFilas; ff++)
        for (cc = (f==ff) ? c+1 : 0; cc < nColumnas; cc++)
           if (e.tablero[f][c]  e.tablero[ff][cc])
             valor++;
             
  if ((e.filaEspacioBlanco + e.colEspacioBlanco) % 2)             
    valor++;
  
  return valor;
}



bool problemaResoluble(estado e1, estado e2)
{
  int valorE1, valorE2;
  
  e1.tablero[e1.filaEspacioBlanco][e1.colEspacioBlanco] = nFilas*nColumnas;
  valorE1 = calcular(e1);  
  e1.tablero[e1.filaEspacioBlanco][e1.colEspacioBlanco] = VALOR_ESPACIO_BLANCO;
   
  e2.tablero[e2.filaEspacioBlanco][e2.colEspacioBlanco] = nFilas*nColumnas;
  valorE2 = calcular(e2);
  e2.tablero[e2.filaEspacioBlanco][e2.colEspacioBlanco] = VALOR_ESPACIO_BLANCO;
  
  return !((valorE1+valorE2) % 2);
}



int main(int argc, char** argv)
{
  estado *peInicial,*peFinal;
  int nAlg, nHeur;


  tratarArgumentos(argc,argv, &nAlg, &nHeur);
  leerEstadosIF(&peInicial,&peFinal);
  
  if (problemaResoluble(*peInicial,*peFinal))
  {
    int i, nodosTotales;
    resultadoBusqueda res;
    FILE *fmovs,*fdatosGenerales;
    struct  tms tms;
    float penetracion;    /* L / T */

    res = busqueda(*peInicial, *peFinal, nAlg, nHeur);
    fmovs = fopen("solucion","w");
    for (i=0; i < res.numMovs; i++)
      escribirPaso(res.movs[i],fmovs);
    fclose(fmovs);

    nodosTotales = res.nodosGenerados + res.nodosRepetidos;
    penetracion = (nodosTotales) ? (res.numMovs / (float) nodosTotales) : 1;  
    fdatosGenerales = fopen("generales","w");
    fprintf(fdatosGenerales,"%d\n%d\n%d\n%d\n%d\n%.3f\n",
            nodosTotales, 
res.nodosGenerados, 
res.nodosRepetidos, 
res.maxProfundidad, 
            res.numMovs);
    
    times(&tms); 
    fprintf(fdatosGenerales,"%.3f seg\n",tms.tms_utime / (float)CLK_TCK);
    
    fclose(fdatosGenerales);    

    return 0;
  }
  else  
  {
    printf("Estados pertenecientes a configuraciones disjuntas") ;
    return 1;
  }  
}

De vuelta al seudocódigo.