Problem:
Problem F: Traveling Cube

On a small planet named Bandai, a landing party of the starship Tadamigawa discovered colorful
cubes traveling on flat areas of the planet surface, which the landing party named beds. A cube
appears at a certain position on a bed, travels on the bed for a while, and then disappears. After
a longtime observation, a science officer Lt. Alyssa Ogawa of Tadamigawa found the rule how a
cube travels on a bed.

A bed is a rectangular area tiled with squares of the same size.

One of the squares is colored red,

one colored green,

one colored blue,

one colored cyan,

one colored magenta,

one colored yellow,

one or more colored white, and

all others, if any, colored black.

Initially, a cube appears on one of the white squares. The cube’s faces are colored as follows.

top red
bottom cyan
north green
south magenta
east blue
west yellow

The cube can roll around a side of the current square at a step and thus rolls on to an adjacent
square. When the cube rolls on to a chromatically colored (red, green, blue, cyan, magenta or
yellow) square, the top face of the cube after the roll should be colored the same. When the
cube rolls on to a white square, there is no such restriction. The cube should never roll on to a
black square.

Throughout the travel, the cube can visit each of the chromatically colored squares only once,
and any of the white squares arbitrarily many times. As already mentioned, the cube can never
visit any of the black squares. On visit to the final chromatically colored square, the cube
disappears. Somehow the order of visits to the chromatically colored squares is known to us
before the travel starts.

Your mission is to find the least number of steps for the cube to visit all the chromatically
colored squares in the given order.

Input

The input is a sequence of datasets. A dataset is formatted as follows:

w d

c11 . . . cw1
. .
. .
. .
c1d . . . cwd
v1v2v3v4v5v6

The first line is a pair of positive integers w and d separated by a space. The next d lines are
w-character-long strings c11 . . . cw1 , . . . , c1d . . . cwd with no spaces. Each character cij is one of
the letters r, g, b, c, m, y, w and k, which stands for red, green, blue, cyan, magenta, yellow,
white and black respectively, or a sign #. Each of r, g, b, c, m, y and # occurs once and only once
in a dataset. The last line is a six-character-long string v1v2v3v4v5v6 which is a permutation of
“rgbcmy”.

The integers w and d denote the width (the length from the east end to the west end) and the
depth (the length from the north end to the south end) of a bed. The unit is the length of a
side of a square. You can assume that neither w nor d is greater than 30.

Each character cij shows the color of a square in the bed. The characters c11 , cw1 , c1d and cwd
correspond to the north-west corner, the north-east corner, the south-west corner and the south-
east corner of the bed respectively. If cij is a letter, it indicates the color of the corresponding
square. If cij is a #, the corresponding square is colored white and is the initial position of the
cube.

The string v1v2v3v4v5v6 shows the order of colors of squares to visit. The cube should visit the
squares colored v1, v2 , v3 , v4 , v5 and v6 in this order.

The end of the input is indicated by a line containing two zeros separated by a space.

Output

For each input dataset, output the least number of steps if there is a solution, or "unreachable"
if there is no solution. In either case, print it in one line for each input dataset.

Sample Input

10 5
kkkkkwwwww
w#wwwrwwww
wwwwbgwwww
kwwmcwwwkk
kkwywwwkkk
rgbcmy
10 5
kkkkkkkkkk
k#kkkkkkkk
kwkkkkkwwk
kcmyrgbwwk
kwwwwwwwwk
cmyrgb
10 5
kkkkkkkkkk
k#kkkkkkkk
kwkkkkkwkk
kcmyrgbwwk
kwwwwwwwwk
cmyrgb
0 0

Output for the Sample Input

9
49
unreachable

Solution in C++ (judge verdict: Accepted)

#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <cassert>
#include <memory>
#include <time.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
const double EPS = 1e-9;
const double PI  = acos(-1.0);

enum FACE { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT };

template <class T> class die {
public:
  die() {
  }
  die(T top, T front, T left, T right, T back, T bottom) {
    var[TOP] = top; var[FRONT] = front; var[LEFT] = left;
    var[RIGHT] = right; var[BACK] = back; var[BOTTOM] = bottom;
  }
  T& operator[] (FACE f) { return var[f]; }
  const T& operator[] (FACE f) const { return var[f]; }
  void roll_x() { roll(TOP, BACK, BOTTOM, FRONT); }
  void roll_y() { roll(TOP, LEFT, BOTTOM, RIGHT); }
  void roll_z() { roll(FRONT, RIGHT, BACK, LEFT); }
private:
  void roll(FACE a, FACE b, FACE c, FACE d) {
    T tmp = var[a];
    var[a] = var[b]; var[b] = var[c];
    var[c] = var[d]; var[d] = tmp;
  }
  T var[6];
// optional
public:
  bool operator==(const die<T>& b) const {
    const die<T> &a = *this;
    return a[TOP] == b[TOP] && a[BOTTOM] == b[BOTTOM] &&
           a[FRONT] == b[FRONT] && a[BACK] == b[BACK] &&
           a[LEFT] == b[LEFT] && a[RIGHT] == b[RIGHT];
  }
  bool equivalent_to(const die& di) {
    for (int k = 0; k < 6; (k & 1 ? roll_y() : roll_x()), ++k)
      for (int i = 0; i < 4; roll_z(), ++i)
        if (*this == di) return true;
    return false;
  }
  vector<die> all_rolls() {
    vector<die> ret;
    for (int k = 0; k < 6; (k & 1 ? roll_y() : roll_x()), ++k)
      for (int i = 0; i < 4; roll_z(), ++i)
        ret.push_back(*this);
    return ret;
  }
  ll hash()const{
	  return var[TOP]
		  +var[FRONT]*256
		  +var[LEFT]*256*256
		  +var[RIGHT]*256*256*256
		  +var[BACK]*256*256*256*256
		  +var[BOTTOM]*256*256*256*256*256;
  }
};

struct node{
	int y,x,route_cnt;
	die<char> di;
	node(int y,int x,int route_cnt,die<char> di):y(y),x(x),route_cnt(route_cnt),di(di){}
};

bool operator<(const node& left,const node& right){
	if(left.y==right.y){
		if(left.x==right.x){
			if(left.route_cnt==right.route_cnt){
				return left.di.hash()<right.di.hash();
			}else{
				return left.route_cnt<right.route_cnt;
			}
		}else{
			return left.x<right.x;
		}
	}else{
		return left.y<right.y;
	}
}

int dy[]={-1,0,1,0};
int dx[]={0,1,0,-1};

int main(){
	int w,d;
	while(cin>>w>>d,w|d){
		vs bed(d);
		pii start;
		REP(i,d){
			cin>>bed[i];
			REP(j,w){
				if(bed[i][j]=='#'){
					start=make_pair(i,j);
				}
			}
		}
		string route;
		cin>>route;

		queue<pair<node,int> > q;
		q.push(make_pair(node(start.first,start.second,0,die<char>('r','m','y','b','g','c')),0));
		set<node> visited;
		int ans=INT_MAX;
		while(q.size()){
			node n=q.front().first;
			int step=q.front().second;
			q.pop();
			REP(dir,4){
				int y=n.y+dy[dir];
				int x=n.x+dx[dir];
				if(y<0||x<0||y>=d||x>=w)continue;
				if(bed[y][x]=='k')continue;
				die<char> di(n.di);
				switch(dir){
				case 0:
					REP(i,3)di.roll_x();
					break;
				case 1:
					di.roll_y();
					break;
				case 2:
					di.roll_x();
					break;
				case 3:
					REP(i,3)di.roll_y();
					break;
				}
				int route_cnt=n.route_cnt;
				if(bed[y][x]!='w'&&bed[y][x]!='#'){
					if(bed[y][x]!=di[TOP]||bed[y][x]!=route[route_cnt])continue;
					route_cnt++;
				}
				if(route_cnt==route.size()){
					ans=step+1;
					goto found;
				}
				node new_node(y,x,route_cnt,di);
				if(EXIST(visited,new_node))continue;
				visited.insert(new_node);
				q.push(make_pair(new_node,step+1));
			}
		}
found:
		if(ans==INT_MAX){
			cout<<"unreachable"<<endl;
		}else{
			cout<<ans<<endl;
		}
	}
}