Problem:
方向音痴のトナカイ

問題

今年も JOI 町にサンタクロースが空からやってきた．JOI 町にある全ての家には子供がいるので，このサンタクロースは JOI 町の全ての家にプレゼントを配ってまわらなければならない．しかし，今年は連れているトナカイが少々方向音痴であり，また建物の上以外に降りることができないため，全ての家にプレゼントを配るためには少々道順を工夫しなければならないようだ．

JOI 町は東西南北に区画整理されており，各区画は家，教会，空き地のいずれかである．JOI 町には 1 つだけ教会がある．次のルールに従い，サンタクロースとトナカイは教会から出発し，全ての家に 1 回ずつプレゼントを配った後，教会に戻る．

今年のトナカイは少々方向音痴であるため，東西南北いずれかの方向にまっすぐ飛ぶことしかできず，空中では方向転換できない．

まだプレゼントを配っていない家の上は自由に通過できる．まだプレゼントを配っていない家には降りることができる．家に降りた時は必ずプレゼントを配り，その後は東西南北いずれかの方向に飛び立つ．

JOI 町の家では，クリスマスの夜はサンタクロースが来るまでは暖炉をつけずに過ごしているが，サンタクロースが飛び立った後は暖炉をつける．暖炉をつけると煙突から煙が出るので，プレゼントを配り終えた家の上を通過することはできない．

教会の上は自由に通過することができる．しかし，教会では礼拝が行われているので，全てのプレゼントを配り終えるまで教会に降りることはできない．

空き地の上は自由に通過することができるが，空き地に降りることはできない．

入力として町の構造が与えられたとき，サンタクロースとトナカイがプレゼントを配る道順が何通りあるかを求めるプログラムを作成せよ．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

各データセットは n+1 行ある．
1 行目には整数 m (1 ≤ m ≤ 10) と整数 n (1 ≤ n ≤ 10) が空白で区切られて書かれている．
2 行目から n+1 行目までの各行には，0，1，2 のいずれかが，
空白で区切られて m 個書かれており，各々が各区画の状態を表している．
北から i 番目，西から j 番目の区画を (i,j) と記述することにすると
(1 ≤ i ≤ n, 1 ≤ j ≤ m)，
第 i+1 行目の j 番目の値は，
区画 (i,j) が空き地である場合は 0 となり，
家である場合は 1 となり，
教会である場合は 2 となる．
教会の個数は 1 であり，家の個数は 1 以上 23 以下である．
ただし，採点用入力データでは配る道順が 2000000 通りをこえることはない．

m, n がともに 0 のとき入力の終了を示す.データセットの数は 5 を超えない．

出力

データセットごとに,プレゼントを配る道順が何通りあるかを表す整数を1 行に出力する．

入出力例

入力例

3 2
1 0 1
1 0 2
3 3
1 1 1
1 0 1
1 1 2
0 0

出力例

2
6

図: 2つ目の入力例 に対する 6 通り全ての道順
（数字は配る順序を表す）

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++ (judge verdict: Time Limit Exceeded)

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>

using namespace std;

static const int di[] = {-1,0,1,0};
static const int dj[] = {0,1,0,-1};

typedef pair<int,int> pi;

#define MAX 16
#define fr first
#define sc second
#define MAXDIR 4

//vector<pi> houses;
int houseId[MAX][MAX];
pi charch;

struct Node{
  bool isCharch;
  bool isHouse;
  bool exist[MAXDIR];
  bool cexist[MAXDIR];
  int linkmax[MAXDIR];
  pi link[MAXDIR][MAX];
  Node():isCharch(false),isHouse(false){
    for(int i=0;i<MAXDIR;++i){
      linkmax[i]=0;
      cexist[i]=exist[i]=false;
    }
  }
};

struct state{
  char ni,nj;
  char cnt;
  int vis;
  state(){}
  state(char si, char sj, char cnt, int vis):ni(si),nj(sj),cnt(cnt),vis(vis){}
};

void bfs(Node M[][MAX], state init, int nhouse, int &ans);

inline bool isinside(int H, int W, int i, int j){
  return 0<=i&&i<H&&0<=j&&j<W;
}
/*
void dfs(const Node M[][MAX], const state &now, int nhouse, int &ans){
  //cout << "DFS" << endl;
  //bi << ' ' << bj << " : " << cnt << endl;
  if( now.cnt + 18 > nhouse ){
    bfs(M,now,nhouse,ans);
    return ;
  }
  

  if( now.cnt == nhouse ){
    for(int k = 0; k < MAXDIR; ++k){
      if( M[now.ni][now.nj].cexist[k] ){
	++ans;
	return ;
      }
    }
  }

  if( now.cnt + 6 >= nhouse ){
    int left = 0;
    int chi=charch.fr;int chj=charch.sc;
    for(int k = 0; k < MAXDIR; ++k){
      left += M[chi][chj].link[k].size();
    }
    for(int k = 0; k < MAXDIR; ++k){
      for(int v = 0; v < M[chi][chj].link[k].size(); ++v){
	pi hs = M[chi][chj].link[k][v];
	if( now.checkvis( houseId[hs.fr][hs.sc]) ){
	  --left;
	}
      }
    }
    if( left == 0 )
      return ;
  }
  
  int ni = now.ni;
  int nj = now.nj;
  for(int k = 0; k < MAXDIR; ++k){
    if( M[ni][nj].exist[k] ){
      for(int v = 0; v < M[ni][nj].link[k].size(); ++v){
	pi pnext = M[ni][nj].link[k][v];
	if( !now.checkvis( houseId[pnext.fr][pnext.sc] ) ){
	  state next(now);
	  next.ni = pnext.fr;
	  next.nj = pnext.sc;
	  next.setvis( houseId[pnext.fr][pnext.sc] );
	  next.cnt++;
	  dfs( M, next, nhouse, ans );
	  break;
	}
      }
    }
  }
  return ;
}
*/
/*
    if( st_now.cnt >= 99 ){
      bool bCont=false;
      for(int i = 0; i < houses.size(); ++i){
	int hi = houses[i].fr;
	int hj = houses[i].sc;
	if( M[hi][hj].isHouse ){
	  if( M[hi][hj].isHouse && st_now.vis&(1<<houseId[hi][hj]) ) continue;
	  bool frontofcharch=false;
	  bCont=true;
	  for(int k = 0; k < MAXDIR; ++k){
	    if( M[hi][hj].cexist[k] ) frontofcharch = true;
	  }
	  for(int k = 0; k < MAXDIR; ++k){
	    if( !M[hi][hj].exist[k] ) continue;
	    for(int v = 0; v < M[hi][hj].link[k].size(); ++v){
	      pi house = M[hi][hj].link[k][v];
	      if( !( st_now.vis&(1<<houseId[house.fr][house.sc]) ) ){
		bCont=false;
		break;
	      }
	    }
	    if(!bCont)break;
	  }
	  
	  if(bCont && !frontofcharch ){
	    break;
	  }
	  bCont=false;
	}
	if( bCont ) break;
      }
      if(bCont)continue;
    }
*/

struct Queue{
  int p;
  state *V;
  Queue():p(0){V=new state[1<<20];}
  ~Queue(){delete [] V;}
  void push(const state &t){
    V[p++]=t;
  }
  state & front(){
    return V[p-1];
  }
  void pop(){--p;}
  bool empty(){
    return p==0;
  }
};

void bfs(Node M[][MAX], state init, int nhouse, int &ans){
  Queue qs;
  qs.push( init );
  int ni,nj;
  int housenum=0;
  int chi=charch.fr;int chj=charch.sc;
  
  for(int k = 0; k < MAXDIR; ++k){
    housenum += M[chi][chj].linkmax[k];
  }
  
  while(!qs.empty()){
    state st_now = qs.front();
    ni = st_now.ni;
    nj = st_now.nj;    
    qs.pop();
    
    if( st_now.cnt == nhouse ){
      for(int l = 0; l < MAXDIR; ++l){
	if( M[ni][nj].cexist[l] ){
	  ++ans;
	  break;
	}
      }
      continue;
    }else{

      int left = housenum;
      for(int k = 0; k < MAXDIR; ++k){
	for(int v = 0; v < M[chi][chj].linkmax[k]; ++v){
	  pi hs = M[chi][chj].link[k][v];
	  if( st_now.vis&(1<<houseId[hs.fr][hs.sc]) ){
	    --left;
	  }
	}
      }
      if( left == 0 )
	continue ;
      
      for(int k = 0; k < MAXDIR; ++k){
	for(int v = 0; v < M[ni][nj].linkmax[k]; ++v){
	  pi next = M[ni][nj].link[k][v];
	  int mask=1<<houseId[next.fr][next.sc];
	  if( !(st_now.vis&mask) ){
	    qs.push( state(next.fr,next.sc,st_now.cnt + 1,st_now.vis|mask) );
	    break;
	  }
	}
      }
    }
  }
  return ;
}

int main()
{
  while(true){
    int ans = 0;
    int W,H;
    scanf("%d%d", &W, &H);
    if(W==0&&W==H)break;
    int iM[MAX][MAX];
    Node M[MAX][MAX];

    int nhouse=0;

    for(int i = 0; i < H; ++i){
      for(int j = 0; j < W; ++j){
	scanf("%d", &iM[i][j]);
	if(iM[i][j]==1){
	  ++nhouse;
	  houseId[i][j]=nhouse;
	  M[i][j].isHouse=true;
	}else if(iM[i][j]==2){
	  M[i][j].isCharch=true;
	  charch = pi(i,j);
	}
      }
    }
    
    for(int i = 0; i < H; ++i){
      for(int j = 0; j < W; ++j){
	for(int k = 0; k < MAXDIR; ++k){
	  int ti=i+di[k];
	  int tj=j+dj[k];
	  while(isinside(H,W,ti,tj)){
	    if(M[ti][tj].isHouse){
	      M[i][j].link[k][ M[i][j].linkmax[k]++ ] = pi(ti,tj);
	      M[i][j].exist[k]=true;
	    }else if(M[ti][tj].isCharch){
	      M[i][j].cexist[k]=true;
	    }
	    ti+=di[k];tj+=dj[k];
	  }
	}
      }
    }
    
    state init(charch.fr,charch.sc,0,0);
    bfs(M,init,nhouse,ans);
    printf("%d\n", ans);

  }
  return 0;

}