Saber todas las combinaciones posibles de un tablero

[aguml]

Bueno, tirando del codigo de y con vuestras explicaciones he llegado a esto:

Código C:

#include <stdio.h>
#include <stdlib.h>
 
/* next lexicographical permutation */
int perm(int *a, int n) {
#   define swap(i, j) {t = a[i]; a[i] = a[j]; a[j] = t;}
    int k, l, t;
 
    /* 1. Find the largest index k such that a[k] < a[k + 1]. If no such
          index exists, the permutation is the last permutation. */
    for (k = n - 1; k && a[k - 1] >= a[k]; k--);
    if (!k--) return 0;
 
    /* 2. Find the largest index l such that a[k] < a[l]. Since k + 1 is
       such an index, l is well defined */
    for (l = n - 1; a[l] <= a[k]; l--);
 
    /* 3. Swap a[k] with a[l] */
    swap(k, l);
 
    /* 4. Reverse the sequence from a[k + 1] to the end */
    for (k++, l = n - 1; l > k; l--, k++)
        swap(k, l);
    return 1;
#   undef swap
}
 
int Diagonal(unsigned *len,int **diagonal,int n)
{
   unsigned j,ok=1;
 
   if(*len == 0){
      *diagonal=(int*)malloc(sizeof(int));
      (*diagonal)[0]=n;
      (*len)++;
   }else{
      for(j=0;j<*len;j++)
         if((*diagonal)[j]==n){
            ok=0;
            break;
         }
      if(ok==1){
         (*len)++;
         *diagonal=(int*)realloc(*diagonal,*len * sizeof(int));
         (*diagonal)[*len-1]=n;
      }
   }
   return ok;
}
 
int esFactible(const int fichas[],unsigned nreinas) {
   int *diagonal_descendente=NULL;
   int *diagonal_ascendente=NULL;
   unsigned i;
   unsigned len_desc=0,len_asc=0;
   int retval=1;
 
   for (i = 0; i < nreinas; ++i) {
      // Si dos valores fila - columna coinciden indican que estamos en
      // la misma diagonal descendente
      if(Diagonal(&len_desc,&diagonal_descendente,i-fichas[i])==0){
         retval=0;
         break;
      }
     
      // Si dos valores fila + columna coinciden indican que estamos en
      // la misma diagonal ascendente
      if(Diagonal(&len_asc,&diagonal_ascendente,i+fichas[i])==0){
         retval=0;
         break;
      }
   }
   free(diagonal_descendente);
   free(diagonal_ascendente);
   diagonal_descendente=NULL;
   diagonal_ascendente=NULL;
     
   // Si no ocurre nada de eso es una solución porque no hay encuentros
   // diagonales y la modelización del espacio de estados evita que haya
   // columnas o filas iguales
   return retval;
}
 
void mostrarAyuda (void)
{
  printf("Instrucciones:\n");
  printf("-------------\n\n");
  printf("Al princicio nos pide el numero de reinas que deseamos colocar en el tablero.\n");
  printf("El numero de reinas sera igual a las dimensiones del tablero, osea que\n");
  printf("el tablero tendra un tamaño de nReinas x nReinas.\n");
  printf("El valor minimo permitido es 4 y el maximo es 10.\n");
}
 
void RepresentarFilaTablero(int size,int posReina)
{
   int i;
 
   for(i=0;i<size;i++)
      if(i!= posReina-1)
         printf("O ");
      else
         printf("X ");
}
 
int main() {
   // Representación del tablero
   // Índice -> Filas -1
   // Valor -> Columnas
   int *reinas;
   unsigned i;
   unsigned nreinas=4;
   int nPermutas=0,nSoluciones=0;
 
   do{
      // Obtener el número de reinas
      printf("Introduce el numero de reinas: ");
      scanf("%d",&nreinas);
 
      if(nreinas <4 || nreinas >10){
         mostrarAyuda();
         system("PAUSE");
         system("CLS");
      }
   }while(nreinas < 4 || nreinas > 10);
 
   // Colocar las reinas en el tablero
   // Crear vector dinámicamente
   reinas = (int*) malloc ( nreinas * sizeof(int) );
 
   // Inicializar vector:
   // (inicialmente, ninguna reina está colocada)
   for (i=0; i<nreinas; i++)
      reinas[i] = i+1;
 
   printf("\n");
 
   // A permutar
   do {
 
      if (esFactible(reinas,nreinas)) {
         printf("SOLUCION (%d):\n",++nSoluciones);
         for (i = 0; i < nreinas; ++i){
            RepresentarFilaTablero(nreinas,reinas[i]);
            printf("  ->  Fila %d\t Columna %d\n",i+1, reinas[i]);
         }
         printf("\n");
         if(nSoluciones % 10 == 0){
            system("PAUSE");
            system("CLS");
         }
      }
      nPermutas++;
   } while(perm(reinas,nreinas));
   printf("En un total de %d combinaciones, se encontraron %d soluciones validas.\n",nPermutas,nSoluciones);
   free(reinas);
   system("PAUSE");
   return 0;
}
 

Creo que funciona correctamente pero la funcion de permutar la saqué de internet y realmente no tengo ni idea de como funciona dicha funcion pero funciona jajaja. Si pudieran explicarme como funciona ya que con los comentarios que trae no me acabo de enterar.
Y tambien sigo interesado en hacer funcionar sin recursividad el otro codigo que os puse por si podeis ayudarme a arreglarlo. Gracias de antemano por toda la ayuda.