HDU 2174 Bridged Marble Rings

题目：Bridged Marble Rings

链接：http://acm.hdu.edu.cn/showproblem.php?pid=2174

题意：如图，要把所有灰色球移动到上圈，每次操作可以转图中虚线圈起的三个圆，求中间圆的最少转数。题目给出的是字符串，g代表灰色球，y代表黄色球，起始位置看标记。

思路：

　　BFS打表+最小表示法

　　令g=1，y=0，用int 表示当前状态。

　　最开始直接用BFS打表，超时超内存，按我最初的算法，所有状态总数为C（26，13）约等于1000多万种。但实际上，因为转动上下两个圈是不增加转数的，所以很多情况是等价的，可以压缩状态数，对于一个状态S，可以转动上圈，下圈使其得到最小表示的状态T。接着存T就可以了。每次，注意，map会超时，后面我改成哈希就过了。。。

　　具体：每次出队一个状态，将该状态对应的13*13个下一步状态（筛选一下）入队。

AC代码：

#include<stdio.h>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;

#define Mod 1000007     //取模的大小，哈希表的大小...
#define Max 100007         //存放的总数
typedef long long LL;
class Hash             //手写哈希
{
  public:
    int hs[Mod];       //哈希值  设定的哈希函数为 原值 % Mod ，所以哈希值有可能是 0 ~ Mod-1
    int next[Max];     //链表    存放哈希值相等的一条链，他的大小取决于所有原值的数量
    LL S[Max];         //存放原值
    int H[Max];        //存放所有哈希值
    int sn;            //不同原值的数量
    int hn;            //不同哈希值的数量
    Hash()             //构造函数: 定义Hash类变量时初始化
    {
      sn=0;
      hn=0;
      for(int i=0;i<Mod;i++)
        hs[i]=0;
    }
    void clear()       //清空函数
    {
      sn=0;
      for(int i=0;i<hn;i++)
        hs[H[i]]=0;
      hn=0;
    }
    void add(LL s)           //加入
    {
      int ha=abs(s)%Mod;     //计算哈希值
      if(hs[ha]==0)          //如果该哈希值还未出现过
      {
        H[hn++]=ha;          //将该哈希值记录起来，同时哈希值数量加 1
      }
      sn++;                  //0 表示结尾，所以从1 开始存，原值数量加 1，特别针对 hs数组
      S[sn]=s;               //将原值记录起来
      next[sn]=hs[ha];       //原本原值记录位置
      hs[ha]=sn;             //最新原值记录位置，如果从0 开始存，就无法判断此时是空还是1个值
      //比如：5 和 10 有一样的哈希值 ，并且 5 和 10 先后加入 那么有：
      //5 加入: next[1] = 0; hs[5] = 1; hs[5] 是哈希值为5 的头，表示第一个原值在1的位置
      //10加入: next[2] = 1; hs[5] = 2; 表示第一个哈希值为5的在2，第二个在1，第三个不存在
    }
    int find(LL s)           //查找
    {
      int ha=abs(s)%Mod;     //计算哈希值
      int k=hs[ha];          //头
      while(k!=0)
      {
        if(S[k]==s) return k;//找到
        k=next[k];           //下一个节点
      }
      return 0;              //表示没找到
    }
};

int move(int s, int i){
  int gao = (s>>13)&0x1FFF;
  int di = s&0x1FFF;
  if(i==0){
    int tmp = di&1;
    di = di >> 1;
    di = di | (tmp << 12);
  }
  else if(i==1){
    int tmp = gao&1;
    gao = gao >> 1;
    gao = gao | (tmp << 12);
  }
  else{
    int a = (gao & 0x1C00)>>10;
    int b = (di & 0x1C00)>>10;
    gao = gao & 0x3FF;
    di = di & 0x3FF;
    gao = (b<<10)| gao;
    di = (a<<10) | di;
  }
  return (gao<<13)|di;
}

map<int, int> mp;
int c[1<<13];

int min_code(int s){
  int gao = (s>>13)&0x1FFF;
  int di = s&0x1FFF;
  gao = c[gao];
  di = c[di];
  return (gao<<13)|di;
}
int min_code_1(int s){
  int ms=s;
  for(int i=0; i<12; i++){
    int tmp = s&1;
    s >>= 1;
    s = s | (tmp << 12);
    if(ms>s) ms=s;
  }
  return ms;
}

Hash hs;
queue<int> q;

void mov(int ms){
  int a=ms;
  for(int i=0; i<13; i++){
    a=move(a, 0);
    int b=a;
    for(int j=0; j<13; j++){
      b=move(b, 1);
      int c=move(b, 2);
      int mc=min_code(c);
      int cx=hs.find(mc);
      if(cx==0){
        hs.add(mc);
        mp[mc]=mp[ms]+1;
        q.push(mc);
      }
    }
  }
}

void bfs(int s){
  s=min_code(s);
  mp[s]=1;
  q.push(s);
  while(q.size()){
    int a=q.front();
    q.pop();
    mov(a);
  }
}

int main(){
  for(int i=0; i<(1<<13); i++){
    c[i]=min_code_1(i);
  }
  int t=0x3FFE000;
  bfs(t);
  char tmp[30];
  while(~scanf("%s", tmp)){
    int s=0;
    for(int i=0; tmp[i]; i++){
      if(tmp[i]=='g') s=s*2+1;
      else s=s*2;
    }

    if(s==t) printf("0\n");
    else printf("%d\n", mp[min_code(s)]-1);
  }
  return 0;
}