/************
 * playing with permutations:
 * 
 * Given 6 corners of 2 adjacent sides of 
 * a Rubik's Cube, how can they be permuted
 * by just the two F,R moves?
 *
 *   0 - 3 - 4
 *   | f | r |
 *   1 - 2 - 5
 *
 *  I  = [0,1,2,3,4,5]  
 *
 *  F  = [1,2,3,0,4,5]
 *  R  = [0,1,5,2,3,4]
 *
 *  F' = [3,0,1,2,4,5]
 *  R' = [0,1,3,4,5,2]
 *
 *  RESULT : (see perm.out) 
 *           Can only get 1/6'th of the 720 positions = 120
 *           Furthest is a  unique one at 7 moves out = [ 1 0 3 2 5 4 ]
 *           which has top and bottom swapped.
 *
 *           I don't have a good intution for why...
 *
 *  Jim Mahoney 3/16/00
 *************/

#include "Utilities.h"
#include <stdio.h>

#define MAX_DEPTH 11
#define N_digits 6
#define N_fact 720

void print_disjoint(int arr[], int N){
  int i, index, t, target;
  int inner, outer, next_target;
  int ar[N_digits];
  for (i=0;i<N;i++){ // make a copy
    ar[i]=arr[i];
  }
  target=0;
  outer=1;
  while (outer){ // loop over disjoint cycles
    printf("(");
    t=target;
    inner=1;
    while (inner){ // loop over numbers in this cycle
      printf("%i",t);
      for (i=0;i<N;i++){ // find index of where ar[index]=t
	if (ar[i]==t) {
	  index=i;
	  ar[i]=-1;  // don't look at this spot again.
	}
      }
      if (index==target) { // done this cycle?
	inner=0; // done this inner loop
	printf(")");
	next_target=1;
	while (next_target){ 	// find next target.
	  target++;
	  if (target >= N) {
	    outer=0;  // we're done
	    next_target = 0;
	  }
	  else {
	    for (i=0;i<N;i++){
	      if (ar[i]==target){
		next_target=0;  // OK, we have our next target; move on
	      }
	    }
	  }
	}
      }
      else { // next number in cycle
	t=index;
      }
    }
    
  }
}

void rearrange6(int iA[], 
	       int i0, int i1, int i2, int i3, int i4, int i5){
  int tA[N_digits];
  int i;
  for (i=0;i<N_digits;i++){
    tA[i]=iA[i];
  }
  iA[0]=tA[i0];
  iA[1]=tA[i1];
  iA[2]=tA[i2];
  iA[3]=tA[i3];
  iA[4]=tA[i4];
  iA[5]=tA[i5];
}

// with the two arrays as permutations,
// sets first = first*second
void multiply( int firstArray[], int s[] ){
  rearrange6(firstArray, s[0], s[1], s[2], s[3], s[4], s[5]);
}

// which = (0,1,2,3) for one of 4 possible rearrangments.
// inArray is rearraged.  N is size of array
void do_move(int which, int inArray[]){
  switch (which) {
  case 0:
    rearrange6(inArray, 1,2,3,0,4,5 );
    break;
  case 1:
    rearrange6(inArray, 0,1,5,2,3,4 );
    break;
  case 2:
    rearrange6(inArray, 3,0,1,2,4,5 );
    break;
  case 3:
    rearrange6(inArray, 0,1,3,4,5,2 );
    break;
  }
}

void print_array(int inArray[], int N){
  int i;
  printf("[");
  for (i=0;i<N;i++){
    printf(" %i ",inArray[i]);
  }
  printf("]");
}

void descend_tree(int depth, int which_move, int iA[], int seen[]){
  int iT[N_digits];
  int i;
  int j_perm;

  for (i=0;i<N_digits;i++){  // copy the position.
    iT[i]=iA[i];}
  do_move( which_move, iT );  // apply given move

  // mark "seen positions" array
  j_perm = Permutation2Number(iT, N_digits);
  //// printf(" in dt:  depth= %i, which = %i, position = ",depth,which_move);
  //// print_array(iT, N_digits);
  //// printf("\n");
  if (seen[j_perm]>depth) {
    seen[j_perm]=depth;
  }
  if (seen[j_perm]==-1) {
    seen[j_perm]=depth;
  }
  //// printf("         perm = %i, seen[perm] = %i \n", j_perm, seen[j_perm]);

  // descend the tree
  if (depth < (MAX_DEPTH-1)) {
    descend_tree(depth+1, 0, iT, seen);
    descend_tree(depth+1, 1, iT, seen);
    descend_tree(depth+1, 2, iT, seen);
    descend_tree(depth+1, 3, iT, seen);
  }
}

// Let's see if the permutation routines in Utilitiy still work.
void main(){

  int arr[N_digits]; // array to be permuted
  int arb[N_digits]; // another array
  int i,j,total;
  long x;
  int analysis[MAX_DEPTH];  // this needs to be 

  // I'm using N=6 here; 6! = 720
  int seen[N_fact];  // array of which permutations have been seen
                     // after a certain number of moves 

  // mark all permutations unseen so far.
  for (i=0;i<N_fact;i++){
    seen[i]= -1;
  }

  Number2Permutation( arr, 0, N_digits);  // put array in original position.
  seen[0]=0;  // mark at which move we've seen this "solved" position.

  // make all possible moves down to given depth.
  printf(" -- starting to search tree to depth = %i -- \n", MAX_DEPTH);
  descend_tree(1, 0, arr, seen);
  descend_tree(1, 1, arr, seen);
  descend_tree(1, 2, arr, seen);
  descend_tree(1, 3, arr, seen);
  printf(" -- done -- \n");


  // print results for each of 720 permutations of 6 digits.
  for (i=0;i<N_fact;i++){
    printf(" perm %i = ",i);
    Number2Permutation( arr, i, N_digits);
    print_array(arr, N_digits);
    if (seen[i]<0) {
      printf(" \n");}
    else {
      Number2Permutation( arb, 0, N_digits); // starting at solved
      j=0;
      while (1) {
	j++;
	multiply(arb, arr);
	if ( Permutation2Number(arb, N_digits) == 0 ) 
	  break;
	if (j>N_fact) // this shouldn't happen
	  break;
      } 
      printf(" , depth=%i, cycle=%i, ", seen[i], j);
      print_disjoint(arr, N_digits);
      printf("\n");
    }
  }
    printf(" ---- \n");

  // analysis: count how many new positions seen at each level,
  //           and how many reached total.
  for (i=0;i<MAX_DEPTH;i++){
    analysis[i]=0;
  }
  for (i=0;i<MAX_DEPTH;i++){
    for (j=0;j<N_fact;j++){
      if (seen[j]==i){
	analysis[i]++;
      }
    }
  }
  total=0;
  for (i=0;i<MAX_DEPTH;i++){
    total=total+analysis[i];
  }
  printf(" analysis results: \n");
  for (i=0;i<MAX_DEPTH;i++){
    printf(" depth = %i , positions = %i \n", i, analysis[i]);
  }
  printf(" ---- total positions = %i \n", total);


  //////// testing: show original position and 4 possible moves.
  //Number2Permutation( arr, 0, 6);
  //printf(" Solved position : ");
  //print_array( arr, N_digits );
  //printf(" \n");

  // for (i=0;i<4;i++){
  //  Number2Permutation( arr, 0, 6);
  //  do_move(i, arr);
  //  printf(" move %i : ",i);
  //  print_array( arr, N_digits );
  //  printf(" \n");
  //}



  ///////////// testing: this prints out all permutations 
  ////////////           of [ 0 1 2 3 4 5 ]
  //  for (x=0;x<N_fact;x++){
  //  Number2Permutation( arr, x, N_digits);
  //  printf(" %i : [ %i %i %i %i %i %i ] \n", x, 
  //	   arr[0],arr[1],arr[2],arr[3],arr[4],arr[5]);
  //}


    
}