USACO 3.2 Magic Squares (msquares) 题解

状态总共只有8!个，不多，用广度优先找最优。

---

我的代码用了个很损的办法：HASH，用HASH表记录从初始达到每一种局面(8!==40320)的最优步数。说到底这也是一种动态规划（记忆化）的思路。

而在HASH表中，const BESTSTEP_HASH[]表示了每一种状态的值——用位运算算出来的，每个格占3位，例如0x53997，二进制表示为“001 010 011 100 101 110 111”，就是局面“1 2 3 4 5 6 7 8”。
查找的时候只需要算一下待查找局面的HASH值，二分查找（可以看一下，const是预先按顺序排好的）。
常数表开了384KB，自己都不忍看了。我在想是不是所有比赛都可以交这么长的程序。

---

USACO官方的解析用了最短路径，xD,有前途。值得一提的是，最短路径做时，图很稀疏，SPFA非常好用。

我的代码。提交2次——第一次用了一般的HASH结果爆内存。
常数表可以在这里下载：http://www.fs2you.com/files/a9022d51-2acb-11dd-964b-00142218fc6e/

/**/ /*
ID:
LANG: C++
TASK: msquare
*/
#include  < cstdlib >
#include  < iostream >
#include  < fstream >
using   namespace  std;
const   int  BESTSTEP_HASH[ 40320 ]  =   ... {
0x53977, 0x5397e, 0x539af, 
/**//*
常数表略去大部分，有300多KB。
如果要用，我建议自己生成。 
当然你也可以从这里下载：http://www.fs2you.com/files/a9022d51-2acb-11dd-964b-00142218fc6e/
*/
, 0xfac642, 0xfac650, 0xfac681, 0xfac688
} ;
int  beststep[ 40320 ];

struct  QNODE
... {
    int step;
    int state[8];
    QNODE *next;
    QNODE *pred;
    char predproc;
} ;
int  tar[ 8 ];
int  nqueue;
QNODE  * front,  * rear;

inline  int  shash( int  state[])
... {
    int sum, t;
    sum = 0;
    for (int i=0; i<8; i++)
    ...{
        t = state[i]-1;
        t <<= i*3;
        sum += t;
    }
    return sum;
}

int  findkey( int  key)
... {
    int l, r, mid;
    l = 0; r = 40320-1;
    while (l <= r)
    ...{
        mid = (l+r)/2;
        if (key < BESTSTEP_HASH[mid]) r = mid-1;
            else if (key > BESTSTEP_HASH[mid]) l = mid+1;
            else break;
    }    
    return mid;
}

char  existbetter( int  chkstate[],  int  chkstep)
... {
    int pos;
    pos = findkey(shash(chkstate));
    if (beststep[pos]==0 || beststep[pos]>chkstep) return 0;
        else return 1;
}

void  addnode( int  newstate[],  int  newstep,  char  newproc)
... {
    QNODE *newnode;
    newnode = new QNODE;
    memcpy(newnode->state, newstate, 8*sizeof(int));
    newnode->step = newstep;
    newnode->next = NULL;
    newnode->pred = front;
    newnode->predproc = newproc;
    
    rear->next = newnode;
    rear = newnode;
    nqueue++;
    
    int pos;
    pos = findkey(shash(newstate));
    beststep[pos] = newstep;
}

int  main()
... {
    ifstream fin("msquare.in");
    for (int i=0; i<8; i++) fin >> tar[i];
    fin.close();
    
    QNODE *realfront;
    front = rear = new QNODE;
    realfront = front;
    front->step = 0;
    for (int i=0; i<8; i++) front->state[i] = i+1;
    front->pred = NULL;
    front->next = NULL;
    nqueue = 1;
    
    while (nqueue > 0)
    ...{
        char match;
        match = 1;
        for (int i=0; i<8; i++) if (front->state[i] != tar[i]) ...{match=0; break;}
        if (match) break;

        int nextstate[8];
        //TRANSFORM 1
        for (int i=0; i<8; i++) nextstate[i] = front->state[7-i];
        if (!existbetter(nextstate, (front->step)+1))
            addnode(nextstate, (front->step)+1, 'A');
        
        //TRANSFORM 2
        nextstate[0] = front->state[3];
        for (int i=1; i<=3; i++) nextstate[i] = front->state[i-1];
        nextstate[7] = front->state[4];        
        for (int i=4; i<=6; i++) nextstate[i] = front->state[i+1];
        if (!existbetter(nextstate, (front->step)+1))
            addnode(nextstate, (front->step)+1, 'B');
        
        //TRANSFORM 3
        nextstate[0] = front->state[0];
        nextstate[3] = front->state[3];
        nextstate[4] = front->state[4];
        nextstate[7] = front->state[7];
        nextstate[1] = front->state[6];
        nextstate[2] = front->state[1];
        nextstate[5] = front->state[2];
        nextstate[6] = front->state[5];
        if (!existbetter(nextstate, (front->step)+1))
            addnode(nextstate, (front->step)+1, 'C');
        
        //DELETE FRONT
        //这是不能释放内存，因为需要用前驱推出状态 
        //如果只是求最优步数当然可以马上删 
        front = front->next;
        nqueue--;
    }
    
    char *seq;
    seq = new char[front->step + 1];
    
    QNODE *curr;
    int seqid;
    seqid = front->step - 1;
    curr = front;
    while (curr->pred != NULL)
    ...{
        seq[seqid] = curr->predproc;
        seqid--;
        curr = curr->pred;
    }
    seq[front->step] = '';
    
    ofstream fout("msquare.out");
    fout << front->step << endl;
    fout << seq << endl;
    fout.close();

    QNODE *delpos, *nextpos;
    delpos = realfront;
    while (delpos != NULL)
    ...{
        nextpos = delpos->next;
        delete delpos;
        delpos = nextpos;
    }
    return 0;
}

USACO官方

/**/ /*
Magic Squares
Hal Burch 
This is a shortest path problem, where the nodes of the graph 
are board arrangements, and edges are transformations. There 
are 8! = 40,320 possible board arrangements, so the problem 
can be solved using breadth-first search (since all edges are 
of unit length. 

Number the boards in increasing order lexicographically, so that
 indexing is simpler. 

In order to simplify the calculations, walk the path backward (start
 at the ending arrangement given, find the minimum path to the 
initial configuration following reverse transformations). Then, walk
 backwards in the resulting tree to determine the path. 
*/
#include  < stdio.h >
#include  < assert.h >

/**/ /* the distance from the initial configuration (+1) */
/**/ /* dist == 0 => no know path */
int  dist[ 40320 ];

/**/ /* calculate the index of a board */
int  encode( int   * board)
  ... {
  static int mult[8] = 
    ...{1, 8, 8*7, 8*7*6, 8*7*6*5,
     8*7*6*5*4, 8*7*6*5*4*3, 8*7*6*5*4*3*2};
  
  /**//* used to calculate the position of a number within the
     remaining ones */
  int look[8] = ...{0, 1, 2, 3, 4, 5, 6, 7};
  int rlook[8] = ...{0, 1, 2, 3, 4, 5, 6, 7};
  /**//* rlook[look[p]] = p and look[rlook[p]] = p */

  int lv, rv;
  int t;

  rv = 0;
  for (lv = 0; lv < 8; lv++)
   ...{
    t = look[board[lv]]; /**//* the rank of the board position */
    assert(t < 8-lv); /**//* sanity check */
    rv += t * mult[lv]; 

    assert(look[rlook[7-lv]] == 7-lv); /**//* sanity check */

    /**//* delete t */
    look[rlook[7-lv]] = t;
    rlook[t] = rlook[7-lv];
   }
  return rv;
 }

/**/ /* the set of transformations, in order */
static   int  tforms[ 3 ][ 8 ]  =   ... { ...{8, 7, 6, 5, 4, 3, 2, 1},
     ...{4, 1, 2, 3, 6, 7, 8, 5}, ...{1, 7, 2, 4, 5, 3, 6, 8} } ;

void  do_trans( int   * inboard,  int   * outboard,  int  t)
  ... { /**//* calculate the board (into outboard) that results from doing
      the t'th transformation to inboard */
  int lv;
  int *tform = tforms[t];

  assert(t >= 0 && t < 3);

  for (lv = 0; lv < 8; lv++)
    outboard[lv] = inboard[tform[lv]-1];
 }

void  do_rtrans( int   * inboard,  int   * outboard,  int  t)
  ... { /**//* calculate the board (into outboard) that which would result
      in inboard if the t'th transformation was applied to it */
  int lv;
  int *tform = tforms[t];

  assert(t >= 0 && t < 3);

  for (lv = 0; lv < 8; lv++)
    outboard[tform[lv]-1] = inboard[lv];
 }

/**/ /* queue for breadth-first search */
int  queue[ 40325 ][ 8 ];
int  qhead, qtail;

/**/ /* calculate the distance from each board to the ending board */
void  do_dist( int   * board)
  ... {
  int lv;
  int t1;
  int d, t;

  qhead = 0;
  qtail = 1;

  /**//* the ending board is 0 steps away from itself */
  for (lv = 0; lv < 8; lv++) queue[0][lv] = board[lv];
  dist[encode(queue[0])] = 1; /**//* 0 steps (+ 1 offset for dist array) */

  while (qhead < qtail)
   ...{
    t1 = encode(queue[qhead]);
    d = dist[t1];

    /**//* for each transformation */
    for (lv = 0; lv < 3; lv++)
     ...{
      /**//* apply the reverse transformation */
      do_rtrans(queue[qhead], queue[qtail], lv);

      t = encode(queue[qtail]);
      if (dist[t] == 0) 
       ...{ /**//* found a new board position!  add it to queue */
        qtail++;
        dist[t] = d+1;
       }
     }

    qhead++;
   }
 }

/**/ /* find the path from the initial configuration to the ending board */
void  walk(FILE  * fout)
  ... {
  int newboard[8];
  int cboard[8];
  int lv, lv2;
  int t, d;

  for (lv = 0; lv < 8; lv++) cboard[lv] = lv;
  d = dist[encode(cboard)];
  /**//* start at the ending board */
  while (d > 1)
   ...{
    for (lv = 0; lv < 3; lv++)
     ...{
      do_trans(cboard, newboard, lv);
      t = encode(newboard);
      if (dist[t] == d-1) /**//* we found the previous board! */
       ...{
        /**//* output transformatino */
        fprintf (fout, "%c", lv+'A');

    /**//* find the rest of the path */
        for (lv2 = 0; lv2 < 8; lv2++) cboard[lv2] = newboard[lv2];
    break;
       }
     }
    assert(lv < 3);
    d--;
   }
  fprintf (fout, " ");
 }

int  main( int  argc,  char   ** argv)
  ... {
  FILE *fout, *fin;
  int board[8];
  int lv;

  if ((fin = fopen("msquare.in", "r")) == NULL)
   ...{
    perror ("fopen fin");
    exit(1);
   }
  if ((fout = fopen("msquare.out", "w")) == NULL)
   ...{
    perror ("fopen fout");
    exit(1);
   }

  for (lv = 0; lv < 8; lv++) 
   ...{
    fscanf (fin, "%d", &board[lv]);
    board[lv]--; /**//* use 0-based instead of 1-based */
   }

  /**//* calculate the distance from each board to the ending board */
  do_dist(board);

  for (lv = 0; lv < 8; lv++) board[lv] = lv;

  /**//* output the distance from and the path from the initial configuration */
  fprintf (fout, "%d ", dist[encode(board)]-1);
  walk(fout);

  return 0;
 }