Problem:
氷の迷路
四角のマスを縦横にならべた長方形の迷路があります。この迷路では東西南北の隣接するマスへ移動しながら、スタートのマスSを出発し、ゴールのマスGを目指します。マスの種類には、平原、山、氷の３種類があります。SとGは、平原のマスに置かれています。平原のマスには移動できますが、山のマスには移動できません。氷のマスは移動できますが、条件によって氷が割れ動けなくなります。
氷のマスは東西南北に隣接するもの全体でひとつの塊として扱われます。
氷の塊のなかで、マスの個数の半分より多くのマスに移動すると、塊全体が割れます。
例えば、図１は与えられた迷路の最短経路のステップ数が 11 であることを示しています。
図1
しかし、図２のように氷のマスを通って近道をしようとすると、大きさが６の氷の塊に対する４回目の移動後に動けなくなってしまいGには到達できません。
図2
このような迷路の情報を入力とし、SからGまでの最短経路のステップ数を求めるプログラムを作成してください。マスの種類はそれぞれ以下の文字で表されます：
文字（半角）
マスの種類
. （ピリオド）
平原
#（シャープ）
山
X
氷
与えられる迷路は必ず解けるものとします。迷路はその東西方向のマスの数
X
、南北方向のマスの数
Y
と
X
×
Y
個の文字として与えられます。
入力
複数のデータセットが与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
X
Y
line
1
line
2
:
line
Y
1行目に迷路の大きさを表す整数
X
,
Y
(2 ≤
X, Y
≤ 12) が与えられます。続く
Y
行に迷路の
i
行目の情報
line
i
(長さ
X
の半角英文字列) が与えられます。
データセットの数は 40 を超えない。
出力
データセットごとに、最小のステップ数を１行に出力します。
入力例
5 5
.X.S.
.X#..
.XX##
.#XG.
..X..
7 3
SXX.XXG
X.#.#X.
XXX.XX#
4 4
S...
X.X.
GX..
...X
10 10
..XXXXX.XX
.X.#.#X.XX
SX.#X.X..X
#X.##.X.XX
..XXXX#.XX
##.##.##XX
....X.XX#X
.##X..#X#X
....XX#..X
...#XXG..X
0 0
出力例
11
10
10
33

Submitted solutions:

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=74;
		vis[sx][sy]=true;
		rec(sx,sy,0);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3220
final_rank: 5

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=74;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3212
final_rank: 2

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=74;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3220
final_rank: 5

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=75;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3216
final_rank: 4

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=77;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3212
final_rank: 2

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=80;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3176
final_rank: 1

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=90;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 90
memory_kb: 3240
final_rank: 11

code_snippet: #include<iostream>
#include<queue>
using namespace std;
int H,W;
string S[12];
int sx,sy,gx,gy;
int A[12][12];
int dx[4]={1,0,0,-1},dy[4]={0,1,-1,0};
int dfs(int x,int y,int col)
{
	A[x][y]=col;
	int ret=1;
	for(int r=0;r<4;r++)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(A[tx][ty]==-2)ret+=dfs(tx,ty,col);
	}
	return ret;
}
int xcnt[150],nowcnt[150];
int dg[12][12];
bool vis[12][12];
int ans;
void rec(int x,int y,int now,int nr)
{
	if(gx==x&&gy==y)ans=now;
	if(ans<=now+dg[x][y])return;
	for(int r=0;r<4;r++)if(r+nr!=3)
	{
		int tx=x+dx[r],ty=y+dy[r];
		if(tx<0||ty<0||tx>=H||ty>=W)continue;
		if(vis[tx][ty]||A[tx][ty]==-1)continue;
		bool ok=true;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]++;
			if(nowcnt[A[tx][ty]]*2>xcnt[A[tx][ty]])ok=false;
		}
		vis[tx][ty]=true;
		if(ok)rec(tx,ty,now+1,r);
		vis[tx][ty]=false;
		if(A[tx][ty]>0)
		{
			nowcnt[A[tx][ty]]--;
		}
	}
}
main()
{
	while(cin>>W>>H,H)
	{
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)
		{
			A[i][j]=0;
			vis[i][j]=false;
		}
		for(int i=0;i<H;i++)
		{
			cin>>S[i];
			for(int j=0;j<W;j++)
			{
				if(S[i][j]=='X')A[i][j]=-2;
				else if(S[i][j]=='#')A[i][j]=-1;
				else
				{
					if(S[i][j]=='S')sx=i,sy=j;
					else if(S[i][j]=='G')gx=i,gy=j;
				}
			}
		}
		int xc=0;
		for(int i=0;i<H;i++)for(int j=0;j<W;j++)if(A[i][j]==-2)
		{
			xc++;
			xcnt[xc]=dfs(i,j,xc);
			nowcnt[xc]=0;
		}
		{
			for(int i=0;i<H;i++)for(int j=0;j<W;j++)dg[i][j]=H*W*2;
			dg[gx][gy]=0;
			queue<pair<int,int> >P;
			P.push(make_pair(gx,gy));
			while(!P.empty())
			{
				int x=P.front().first,y=P.front().second;
				P.pop();
				for(int r=0;r<4;r++)
				{
					int tx=x+dx[r],ty=y+dy[r];
					if(tx<0||ty<0||tx>=H||ty>=W)continue;
					if(A[tx][ty]==-1||dg[tx][ty]<=dg[x][y]+1)continue;
					dg[tx][ty]=dg[x][y]+1;
					P.push(make_pair(tx,ty));
				}
			}
		}
		ans=H*W/2;
		if(ans<90)ans=90;
		vis[sx][sy]=true;
		rec(sx,sy,0,-1);
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 90
memory_kb: 3216
final_rank: 10

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

void solve(int h, int w){
    array<int, 4> dx{-1, 1, 0, 0}, dy{0, 0, -1, 1};
    vector<vector<int>> v(h+2, vector<int>(w+2, -1));
    int sy, sx, gy, gx;
    for (int i = 0; i < h; ++i) {
        string s;
        cin >> s;
        for (int j = 0; j < w; ++j) {
            if(s[j] == 'X') v[i+1][j+1] = 1000;
            else if(s[j] == '#' || s[j] == 'S') v[i+1][j+1] = -1;
            else v[i+1][j+1] = 0;
            if(s[j] == 'S') sy = i+1, sx = j+1;
            else if(s[j] == 'G') gy = i+1, gx = j+1;
        }
    }
    vector<int> M{0};
    for (int i = 0, cur = 1; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            if(v[i+1][j+1] == 1000){
                queue<pair<int, int>> Q;
                Q.emplace(i+1, j+1);
                M.emplace_back();
                v[i+1][j+1] = cur;
                while(!Q.empty()){
                    M.back()++;
                    int y, x; tie(y, x) = Q.front(); Q.pop();
                    for (int k = 0; k < 4; ++k) {
                        if(v[y+dy[k]][x+dx[k]] == 1000){
                            v[y+dy[k]][x+dx[k]] = cur;
                            Q.emplace(y+dy[k], x+dx[k]);
                        }
                    }
                }
                M.back() /= 2;
                cur++;
            }
        }
    }
    for (int ans = abs(sx-gx)+abs(sy-gy); ; ++ans) {
        auto G = v;
        vector<int> m(M.size());
        auto dfs = [&](int y, int x, int dep, auto &&f) -> bool {
            if(gy == y && gx == x) return true;
            if(dep+abs(gy-y)+abs(gx-x) > ans) return false;
            for (int k = 0; k < 4; ++k) {
                int p = G[y+dy[k]][x+dx[k]];
                if(p == 0){
                    G[y+dy[k]][x+dx[k]] = -1;
                    if(f(y+dy[k], x+dx[k], dep+1, f)) return true;
                    G[y+dy[k]][x+dx[k]] = 0;
                }else if(p > 0 && m[p]+1 <= M[p]){
                    m[p]++;
                    G[y+dy[k]][x+dx[k]] = -1;
                    if(f(y+dy[k], x+dx[k], dep+1, f)) return true;
                    G[y+dy[k]][x+dx[k]] = p;
                    m[p]--;
                }
            }
            return false;
        };
        if(dfs(sy, sx, 0, dfs)){
            cout << ans << "\n";
            return;
        }
    }


}

int main() {
    int h, w;
    while(cin >> w >> h, h){
        solve(h, w);

    }
    return 0;
}
accuracy: 1
time_ms: 540
memory_kb: 3184
final_rank: 14

code_snippet: #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <tuple>
#include <queue>
using namespace std;

int H, W, sx, sy, gx, gy, col[13][13], G[130], cnts, bit[130]; char c[13][13]; long long J[130], JJ[130];
int dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 };
map<long long, int>Map[13][13];

void init() {
	H = 0; W = 0; sx = 0; sy = 0; gx = 0; gy = 0; cnts = 0;
	for (int i = 0; i < 13; i++) {
		for (int j = 0; j < 13; j++) { col[i][j] = 0; Map[i][j].clear(); c[i][j] = 0; }
	}
	for (int i = 0; i < 130; i++) { G[i] = 0; J[i] = 0; JJ[i] = 0; }
}

void dfs1(int px, int py) {
	if (px < 0 || py < 0 || px >= H || py >= W) return;
	if (col[px][py] >= 1 || c[px][py] != 'X') return;
	col[px][py] = cnts; G[cnts]++;
	for (int i = 0; i < 4; i++) {
		dfs1(px + dx[i], py + dy[i]);
	}
}

int main() {
	while (true) {
		init();
		cin >> W >> H; if (H == 0 && W == 0) break;
		for (int i = 0; i < H; i++) {
			for (int j = 0; j < W; j++) {
				cin >> c[i][j];
				if (c[i][j] == 'S') { sx = i; sy = j; c[i][j] = '.'; }
				if (c[i][j] == 'G') { gx = i; gy = j; c[i][j] = '.'; }
			}
		}
		for (int i = 0; i < H; i++) {
			for (int j = 0; j < W; j++) {
				if (c[i][j] != 'X' || col[i][j] >= 1) continue;
				cnts++; dfs1(i, j);
			}
		}
		JJ[1] = 1;
		for (int i = 1; i <= cnts; i++) { J[i] = (G[i] / 2 + 1); if (i >= 2) JJ[i] = JJ[i - 1] * J[i - 1]; }

		queue<tuple<int, int, long long>> Q;
		Q.push(make_tuple(sx, sy, 0)); Map[sx][sy][0] = 1;
		
		int ans = (1 << 30);

		while (!Q.empty()) {
			int px = get<0>(Q.front()), py = get<1>(Q.front()); long long V = get<2>(Q.front()); Q.pop();
			int cost = Map[px][py][V];
			if (px == gx && py == gy) {
				ans = min(ans, cost); break;
			}

			long long VV = V;
			for (int i = 1; i <= cnts; i++) { bit[i] = VV % J[i]; VV /= J[i]; }

			for (int i = 0; i < 4; i++) {
				int vx = px + dx[i], vy = py + dy[i];
				if (vx < 0 || vy < 0 || vx >= H || vy >= W || c[vx][vy] == '#') continue;

				long long I = V; bool die = false;
				if (col[vx][vy] >= 1) {
					I += JJ[col[vx][vy]];
					if (bit[col[vx][vy]] + 1 == J[col[vx][vy]]) die = true;
				}
				if (die == true) continue;
				
				if (Map[vx][vy][I] == 0) {
					Map[vx][vy][I] = cost + 1; Q.push(make_tuple(vx, vy, I));
				}
			}
		}
		cout << ans - 1 << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 530
memory_kb: 50596
final_rank: 16

code_snippet: #include <queue>
#include <string>
#include <vector>
#include <iostream>
using namespace std;
const vector<int> dx = { 1, 0, -1, 0 };
const vector<int> dy = { 0, 1, 0, -1 };
int H, W, sx, sy, gx, gy, comp_cnt; vector<int> comp_size; vector<vector<int> > dist, used; vector<vector<int> > comp; vector<string> s;
void comp_dfs(int x, int y) {
	comp[x][y] = comp_cnt;
	++comp_size[comp_cnt];
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] == 'X' && comp[tx][ty] == -1) {
			comp_dfs(tx, ty);
		}
	}
}
bool reach(int x, int y, int rem) {
	if (x == gx && y == gy) return true;
	if (dist[x][y] > rem) return false;
	used[x][y] = rem;
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] != '#' && (s[tx][ty] != 'X' || comp_size[comp[tx][ty]] >= 2) && used[tx][ty] == -1) {
			bool ok = true;
			for (int j = 0; j < 4 && ok; ++j) {
				int rx = tx + dx[j], ry = ty + dy[j];
				if (0 <= rx && rx < H && 0 <= ry && ry < W && used[rx][ry] >= rem + 2) ok = false;
			}
			if (ok) {
				if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] -= 2;
				if (reach(tx, ty, rem - 1)) return true;
				if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] += 2;
			}
		}
	}
	used[x][y] = -1;
	return false;
}
int main() {
	while (cin >> W >> H, H != 0) {
		s = vector<string>(H);
		for (int i = 0; i < H; ++i) {
			cin >> s[i];
			if (s[i].find('S') != string::npos) sx = i, sy = s[i].find('S');
			if (s[i].find('G') != string::npos) gx = i, gy = s[i].find('G');
		}
		comp = vector<vector<int> >(H, vector<int>(W, -1));
		comp_size.clear();
		comp_cnt = 0;
		for (int i = 0; i < H; ++i) {
			for (int j = 0; j < W; ++j) {
				if (s[i][j] == 'X' && comp[i][j] == -1) {
					comp_size.push_back(0);
					comp_dfs(i, j);
					++comp_cnt;
				}
			}
		}
		dist = vector<vector<int> >(H, vector<int>(W, -1));
		dist[gx][gy] = 0;
		queue<pair<int, int> > que; que.push(make_pair(gx, gy));
		while (!que.empty()) {
			pair<int, int> u = que.front(); que.pop();
			for (int i = 0; i < 4; ++i) {
				int tx = u.first + dx[i], ty = u.second + dy[i];
				if (0 <= tx && tx < H && 0 <= ty && ty < W && dist[tx][ty] == -1) {
					dist[tx][ty] = dist[u.first][u.second] + 1;
					que.push(make_pair(tx, ty));
				}
			}
		}
		used = vector<vector<int> >(H, vector<int>(W, -1));
		int steps = 1;
		while (!reach(sx, sy, steps)) ++steps;
		cout << steps << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 3184
final_rank: 12

code_snippet: #include <string>
#include <vector>
#include <iostream>
using namespace std;
const vector<int> dx = { 1, 0, -1, 0 };
const vector<int> dy = { 0, 1, 0, -1 };
int H, W, sx, sy, gx, gy, comp_cnt; vector<int> comp_size; vector<vector<int> > used; vector<vector<int> > comp; vector<string> s;
void comp_dfs(int x, int y) {
	comp[x][y] = comp_cnt;
	++comp_size[comp_cnt];
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] == 'X' && comp[tx][ty] == -1) {
			comp_dfs(tx, ty);
		}
	}
}
bool reach(int x, int y, int rem) {
	if (x == gx && y == gy) return true;
	if (abs(x - gx) + abs(y - gy) > rem) return false;
	used[x][y] = rem;
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] != '#' && (s[tx][ty] != 'X' || comp_size[comp[tx][ty]] >= 2) && used[tx][ty] == -1) {
			bool ok = true;
			for (int j = 0; j < 4 && ok; ++j) {
				int rx = tx + dx[j], ry = ty + dy[j];
				if (0 <= rx && rx < H && 0 <= ry && ry < W && used[rx][ry] >= rem + 2) ok = false;
			}
			if (ok) {
				if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] -= 2;
				if (reach(tx, ty, rem - 1)) return true;
				if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] += 2;
			}
		}
	}
	used[x][y] = -1;
	return false;
}
int main() {
	while (cin >> W >> H, H != 0) {
		s = vector<string>(H);
		for (int i = 0; i < H; ++i) {
			cin >> s[i];
			if (s[i].find('S') != string::npos) sx = i, sy = s[i].find('S');
			if (s[i].find('G') != string::npos) gx = i, gy = s[i].find('G');
		}
		comp = vector<vector<int> >(H, vector<int>(W, -1));
		comp_size.clear();
		comp_cnt = 0;
		for (int i = 0; i < H; ++i) {
			for (int j = 0; j < W; ++j) {
				if (s[i][j] == 'X' && comp[i][j] == -1) {
					comp_size.push_back(0);
					comp_dfs(i, j);
					++comp_cnt;
				}
			}
		}
		used = vector<vector<int> >(H, vector<int>(W, -1));
		int steps = 1;
		while (!reach(sx, sy, steps)) ++steps;
		cout << steps << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 3196
final_rank: 13

code_snippet: #include <string>
#include <vector>
#include <iostream>
using namespace std;
const vector<int> dx = { 1, 0, -1, 0 };
const vector<int> dy = { 0, 1, 0, -1 };
int H, W, sx, sy, gx, gy, comp_cnt; vector<int> comp_size, used; vector<vector<int> > comp; vector<string> s;
void comp_dfs(int x, int y) {
	comp[x][y] = comp_cnt;
	++comp_size[comp_cnt];
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] == 'X' && comp[tx][ty] == -1) {
			comp_dfs(tx, ty);
		}
	}
}
bool reach(int x, int y, int rem) {
	if (x == gx && y == gy) return true;
	if (abs(x - gx) + abs(y - gy) > rem) return false;
	used[x] += 1 << y;
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i], ty = y + dy[i];
		if (0 <= tx && tx < H && 0 <= ty && ty < W && s[tx][ty] != '#' && (s[tx][ty] != 'X' || comp_size[comp[tx][ty]] >= 2) && !((used[tx] >> ty) & 1)) {
			if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] -= 2;
			if (reach(tx, ty, rem - 1)) return true;
			if (s[tx][ty] == 'X') comp_size[comp[tx][ty]] += 2;
		}
	}
	used[x] -= 1 << y;
	return false;
}
int main() {
	while (cin >> W >> H, H != 0) {
		s = vector<string>(H);
		for (int i = 0; i < H; ++i) {
			cin >> s[i];
			if (s[i].find('S') != string::npos) sx = i, sy = s[i].find('S');
			if (s[i].find('G') != string::npos) gx = i, gy = s[i].find('G');
		}
		comp = vector<vector<int> >(H, vector<int>(W, -1));
		comp_size.clear();
		comp_cnt = 0;
		for (int i = 0; i < H; ++i) {
			for (int j = 0; j < W; ++j) {
				if (s[i][j] == 'X' && comp[i][j] == -1) {
					comp_size.push_back(0);
					comp_dfs(i, j);
					++comp_cnt;
				}
			}
		}
		used = vector<int>(H, 0);
		int steps = 1;
		while (!reach(sx, sy, steps)) ++steps;
		cout << steps << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 710
memory_kb: 3192
final_rank: 15

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 12

struct Info{
	Info(){
		row = col = 0;
	}
	Info(int arg_row,int arg_col){
		row = arg_row;
		col = arg_col;
	}
	void set(int arg_row,int arg_col){
		row = arg_row;
		col = arg_col;
	}
	bool operator==(const struct Info &arg) const{
		return row == arg.row && col == arg.col;
	}
	int row,col;
};

int W,H;
int ice_index,index_table[NUM][NUM];
int diff_row[4] = {1,0,-1,0},diff_col[4] = {0,1,0,-1};
int num_member[NUM*NUM],ice_count_table[NUM*NUM];
int ans;
char base_map[NUM][NUM+1];
bool visited[NUM][NUM];
Info start,goal;

bool rangeCheck(Info info){
	if(info.row >= 0 && info.row <= H-1 && info.col >= 0 && info.col <= W-1){
		return true;
	}else{
		return false;
	}
}

void recursive(Info info,int sum_cost){

	if(info == goal){
		ans = min(ans,sum_cost);
		return;
	}

	//最小値が出ないならreturn
	if(sum_cost+abs(info.row-goal.row)+abs(info.col-goal.col) >= ans){
		return;
	}

	int adj_row,adj_col;
	int adj_row_2,adj_col_2;

	bool FLG;

	for(int i = 0; i < 4; i++){

		adj_row = info.row+diff_row[i];
		adj_col = info.col+diff_col[i];

		if(rangeCheck(Info(adj_row,adj_col)) == false || base_map[adj_row][adj_col] == '#' ||
				visited[adj_row][adj_col] == true)continue;

		//最小値が出ないならcontinue
		if(sum_cost+abs(adj_row-goal.row)+abs(adj_col-goal.col) >= ans)continue;

		FLG = true;

		for(int k = 0; k < 4; k++){
			adj_row_2 = adj_row+diff_row[k];
			adj_col_2 = adj_col+diff_col[k];

			if(rangeCheck(Info(adj_row_2,adj_col_2)) == false || base_map[adj_row_2][adj_col_2] == '#' ||
					(adj_row_2 == info.row && adj_col_2 == info.col))continue;

			if(visited[adj_row_2][adj_col_2]){
				FLG = false;
				break;
			}
		}

		if(!FLG)continue;

		if(base_map[adj_row][adj_col] == '.'){

			visited[adj_row][adj_col] = true;
			recursive(Info(adj_row,adj_col),sum_cost+1);

			visited[adj_row][adj_col] = false;

		}else{ //base_map[adj_row][adj_col] == 'X'

			int tmp_index = index_table[adj_row][adj_col];
			if(ice_count_table[tmp_index]+1 > num_member[tmp_index]/2)continue; //氷が割れるのでcontinue

			visited[adj_row][adj_col] = true;
			ice_count_table[tmp_index]++;
			recursive(Info(adj_row,adj_col),sum_cost+1);

			visited[adj_row][adj_col] = false;
			ice_count_table[tmp_index]--;
		}
	}
}

void func(){

	for(int row = 0; row < H; row++){
		scanf("%s",base_map[row]);
		for(int col = 0; col < W; col++){
			if(base_map[row][col] == 'S'){

				start.set(row,col);
				base_map[row][col] = '.';

			}else if(base_map[row][col] == 'G'){

				goal.set(row,col);
				base_map[row][col] = '.';
			}
		}
	}

	//氷マスを連結させる&枚数を数える
	ice_index = 0;

	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			index_table[row][col] = -1;
		}
	}

	queue<Info> Q;
	int adj_row,adj_col,count;

	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			if(base_map[row][col] != 'X' || index_table[row][col] != -1)continue;

			index_table[row][col] = ice_index;
			Q.push(Info(row,col));

			count = 1;

			while(!Q.empty()){

				for(int i = 0; i < 4; i++){

					adj_row = Q.front().row+diff_row[i];
					adj_col = Q.front().col+diff_col[i];

					if(rangeCheck(Info(adj_row,adj_col)) == false || base_map[adj_row][adj_col] != 'X' ||
							index_table[adj_row][adj_col] != -1)continue;

					index_table[adj_row][adj_col] = ice_index;
					count++;

					Q.push(Info(adj_row,adj_col));
				}
				Q.pop();
			}

			num_member[ice_index] = count;
			ice_index++;
		}
	}

	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			visited[row][col] = false;
		}
	}
	visited[start.row][start.col] = true;

	ans = H*W;
	for(int i = 0; i < ice_index; i++)ice_count_table[i] = 0;

	recursive(start,0);

	printf("%d\n",ans);
}

int main(){

	while(true){
		scanf("%d %d",&W,&H);
		if(W == 0 && H == 0)break;

		func();
	}

	return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 3128
final_rank: 8

code_snippet: #include<bits/stdc++.h>

using namespace std;


int W, H;

char ma[16][16];
char g[16][16];
bool v[16][16];

int maxIce[128];
int ice[128];

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

int ans;
int px, py;
int sx, sy, gx, gy;

bool getMin(int ty, int tx, int turn)
{

    if (turn + abs(ty - gy) + abs(tx - gx) >= ans){
        return (false);
    }

    if (ty == gy && tx == gx){
        ans = turn;
        return (true);
    }

    for (int i = 0; i < 4; i++){
        int mx = tx + dx[i], my = ty + dy[i];
        if (0 <= mx && mx < W && 0 <= my && my < H && px != mx && py != my && v[my][mx]){
            return (false);
        }
    }

    for (int i = 0; i < 4; i++){
        int mx = tx + dx[i], my = ty + dy[i];
        px = tx, py = ty;
        if (0 <= mx && mx < W && 0 <= my && my < H && ma[my][mx] != '#' && !v[my][mx]){
            if (g[my][mx] == -1){
                v[my][mx] = true;
                if (getMin(my, mx, turn + 1)) return (true);
                v[my][mx] = false;
            }
            else if (maxIce[g[my][mx]] >= ice[g[my][mx]] + 1){
                ice[g[my][mx]]++;
                v[my][mx] = true;
                if (getMin(my, mx, turn + 1)) return (true);
                v[my][mx] = false;
                ice[g[my][mx]]--;
            }
        }
    }

    return (false);
}

void label(int ty, int tx, int p)
{
    g[ty][tx] = p;
    maxIce[p]++;

    for (int i = 0; i < 4; i++){
        int mx = tx + dx[i], my = ty + dy[i];

        if (0 <= mx && mx < W && 0 <= my && my < H &&
                    ma[my][mx] == 'X' && g[my][mx] == -1){
            label(my, mx, p);
        }
    }
}

int main()
{
    int idx;

    while (1){
        scanf("%d %d", &W, &H);

        if (W + H == 0){
            break;
        }

        for (int i = 0; i < H; i++){
            scanf("%s", ma[i]);
            for (int j = 0; j < W; j++){
                if (ma[i][j] == 'S'){
                    ma[i][j] = '.';
                    sx = j, sy = i;
                }
                if (ma[i][j] == 'G'){
                    ma[i][j] = '.';
                    gx = j, gy = i;
                }
            }
        }

        memset(g, -1, sizeof(g));
        memset(maxIce, 0, sizeof(maxIce));

        idx = 0;
        for (int i = 0; i < H; i++){
            for (int j = 0; j < W; j++){
                if (ma[i][j] == 'X' && g[i][j] == -1){
                    label(i, j, idx);
                    maxIce[idx++] /= 2;
                }
            }
        }

        memset(ice, 0, sizeof(ice));
        memset(v, 0, sizeof(v));
        px = py = -1;
        v[sy][sx] = true;

        ans = 0;
        while (!getMin(sy, sx, 0)){
            memset(ice, 0, sizeof(ice));
            memset(v, 0, sizeof(v));
            px = py = -1;
            v[sy][sx] = true;
            ans++;
        }

        printf("%d\n", ans);
    }

    return (0);
}
accuracy: 1
time_ms: 90
memory_kb: 3152
final_rank: 9

code_snippet: #include<iostream>
#include<stack>
#include<queue>
#include<cstring>
#define INF 1 << 15
using namespace std;
struct d{
	int x;
	int y;
	int visited[12][12];
	int ic[144];
	int cnt;
};
struct b{
	int x;
	int y;
};
int main(){
	int lx,ly,i,j,nc=1,k,a,min=144,gx,gy,ex,ey;
	int maps[12][12]={0};
	int mx[4]={-1,0,1,0};
	int my[4]={0,-1,0,1};
	int ig[144]={0};
	int f[12][12];
	int mapc[13][13];
	char map[13][13];
	queue<b> q;
	b v,u;
	stack<d> s;
	d r,t;
	while(1){
		cin>>lx>>ly;
			if(lx==0&&ly==0){
				break;
			}
				memset(mapc,-1,sizeof(mapc));
			nc=1;
			memset(maps,0,sizeof(maps));
			memset(ig,0,sizeof(ig));
			min=144;
		for(i=0;i<ly;i++){
			cin>>map[i];
		}
		for(i=0;i<ly;i++){
			for(j=0;j<lx;j++){
					if(map[i][j]=='S'){
					r.x=j;
						r.y=i;
					memset(r.visited,0,sizeof(r.visited));
					memset(r.ic,0,sizeof(r.ic));
					r.cnt=0;
						mapc[i][j]=0;
					s.push(r);
				}
				if(map[i][j]=='G'){
					gx=j;
					gy=i;
				}
				if(map[i][j]=='X'&&maps[i][j]==0){
					v.x=j;
					v.y=i;
					q.push(v);
					while(!q.empty()){
						v=q.front();
						q.pop();
						maps[v.y][v.x]=nc;
						ig[nc]++;
						for(k=0;k<4;k++){
							u=v;
							u.x+=mx[k];
							u.y+=my[k];
							if(map[u.y][u.x]=='X'&&maps[u.y][u.x]==0&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly){
								q.push(u);
								
							}
						}
					}
					if(ig[nc]==1){
						map[v.y][v.x]='#';
					}
					nc++;
					
				}
			}
		}
		v.x=gx;
		v.y=gy;
		
		memset(f,-1,sizeof(f));
		f[gy][gx]=0;
		q.push(v);
		while(!q.empty()){
			v=q.front();
			q.pop();
			for(i=0;i<4;i++){
				u=v;
				u.x+=mx[i];
				u.y+=my[i];
				if(map[u.y][u.x]!='#'&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly&&f[u.y][u.x]==-1){
					q.push(u);
					f[u.y][u.x]=f[v.y][v.x]+1;
				}
			}
		}

		while(!s.empty()){
			r=s.top();
			s.pop();
			if(r.visited[r.y][r.x]==1){
				continue;
			}
			else{
				r.visited[r.y][r.x]=1;
			}
			if(r.cnt+f[r.y][r.x]>=min){
				continue;
			}
			
			for(i=0;i<4;i++){
				t=r;
				t.x+=mx[i];
				t.y+=my[i];
				t.cnt++;
				if(map[t.y][t.x]!='#'&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					
					
						if(mapc[t.y][t.x]>=r.cnt+1||mapc[t.y][t.x]==-1){
							if(map[t.y][t.x]=='G'){
								ex=t.x;
								ey=t.y;
								min=t.cnt;
								mapc[t.y][t.x]=r.cnt+1;
								break;
							}
							if(map[t.y][t.x]=='X'){
								a=maps[t.y][t.x];
								t.ic[a]++;
								if(t.ic[a]<=(ig[a]/2)){
									mapc[t.y][t.x]=r.cnt+1;
									s.push(t);
								}
							}

							else{
								mapc[t.y][t.x]=r.cnt+1;
								s.push(t);
							}
						}
						else{
							if(mapc[t.y][t.x]<=r.cnt){
							continue;
							}
						}
			}
		}
		}
		cout<<mapc[ey][ex]<<endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5696
final_rank: 7

code_snippet: #include<iostream>
#include<stack>
#include<queue>
#include<cstring>
#define INF 1 << 15
using namespace std;
struct d{
	int x;
	int y;
	int visited[12][12];
	int ic[144];
	int cnt;
};
struct b{
	int x;
	int y;
};
int main(){
	int lx,ly,i,j,nc=1,k,a,min=144,gx,gy,ex,ey;
	int maps[12][12]={0};
	int mx[4]={-1,0,1,0};
	int my[4]={0,-1,0,1};
	int ig[144]={0};
	int f[12][12];
	int mapc[13][13];
	char map[13][13];
	queue<b> q;
	b v,u;
	stack<d> s;
	d r,t;
	while(1){
		cin>>lx>>ly;
			if(lx==0&&ly==0){
				break;
			}
				memset(mapc,-1,sizeof(mapc));
			nc=1;
			memset(maps,0,sizeof(maps));
			memset(ig,0,sizeof(ig));
			min=144;
		for(i=0;i<ly;i++){
			cin>>map[i];
		}
		for(i=0;i<ly;i++){
			for(j=0;j<lx;j++){
					if(map[i][j]=='S'){
					r.x=j;
						r.y=i;
					memset(r.visited,0,sizeof(r.visited));
					memset(r.ic,0,sizeof(r.ic));
					r.cnt=0;
						mapc[i][j]=0;
					s.push(r);
				}
				if(map[i][j]=='G'){
					gx=j;
					gy=i;
				}
				if(map[i][j]=='X'&&maps[i][j]==0){
					v.x=j;
					v.y=i;
					q.push(v);
					while(!q.empty()){
						v=q.front();
						q.pop();
						maps[v.y][v.x]=nc;
						ig[nc]++;
						for(k=0;k<4;k++){
							u=v;
							u.x+=mx[k];
							u.y+=my[k];
							if(map[u.y][u.x]=='X'&&maps[u.y][u.x]==0&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly){
								q.push(u);
								
							}
						}
					}
					if(ig[nc]==1){
						map[v.y][v.x]='#';
					}
					nc++;
					
				}
			}
		}
		v.x=gx;
		v.y=gy;
		
		memset(f,-1,sizeof(f));
		f[gy][gx]=0;
		q.push(v);
		while(!q.empty()){
			v=q.front();
			q.pop();
			for(i=0;i<4;i++){
				u=v;
				u.x+=mx[i];
				u.y+=my[i];
				if(map[u.y][u.x]!='#'&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly&&f[u.y][u.x]==-1){
					q.push(u);
					f[u.y][u.x]=f[v.y][v.x]+1;
				}
			}
		}

		while(!s.empty()){
			r=s.top();
			s.pop();
			if(r.visited[r.y][r.x]==1){
				continue;
			}
			else{
				r.visited[r.y][r.x]=1;
			}
			if(r.cnt+f[r.y][r.x]>=min){
				continue;
			}
			
			for(i=0;i<4;i++){
				t=r;
				t.x+=mx[i];
				t.y+=my[i];
				t.cnt++;
				if(map[t.y][t.x]!='#'&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					
				if(mapc[t.y][t.x]>r.cnt+1||mapc[t.y][t.x]==-1){
						mapc[t.y][t.x]=r.cnt+1;
					}
					else{
						if(mapc[t.y][t.x]<=r.cnt){
						continue;
						}
					}
				if(map[t.y][t.x]=='G'&&t.cnt<min&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					ex=t.x;
					ey=t.y;
					min=t.cnt;
					break;
				}
				
					
					if(map[t.y][t.x]=='X'){
						a=maps[t.y][t.x];
						t.ic[a]++;
						if(t.ic[a]<=(ig[a]/2)){
							s.push(t);
						}
					}
					else{
						s.push(t);
					}
				}
			}
		}
		cout<<mapc[ey][ex]<<endl;
	}
	return 0;
}
accuracy: 0.8
time_ms: 10
memory_kb: 5648
final_rank: 17

code_snippet: #include<iostream>
#include<stack>
#include<queue>
#include<cstring>
#define INF 1 << 15
using namespace std;
struct d{
	int x;
	int y;
	int visited[12][12];
	int ic[144];
	int cnt;
};
struct b{
	int x;
	int y;
};
int main(){
	int lx,ly,i,j,nc=1,k,a,min=144,gx,gy,ex,ey;
	int maps[12][12]={0};
	int mx[4]={-1,0,1,0};
	int my[4]={0,-1,0,1};
	int ig[144]={0};
	int f[12][12];
	int mapc[13][13];
	char map[13][13];
	queue<b> q;
	b v,u;
	stack<d> s;
	d r,t;
	while(1){
		cin>>lx>>ly;
			if(lx==0&&ly==0){
				break;
			}
				memset(mapc,-1,sizeof(mapc));
			nc=1;
			memset(maps,0,sizeof(maps));
			memset(ig,0,sizeof(ig));
			min=144;
		for(i=0;i<ly;i++){
			cin>>map[i];
		}
		for(i=0;i<ly;i++){
			for(j=0;j<lx;j++){
					if(map[i][j]=='S'){
					r.x=j;
						r.y=i;
					memset(r.visited,0,sizeof(r.visited));
					memset(r.ic,0,sizeof(r.ic));
					r.cnt=0;
						mapc[i][j]=0;
					s.push(r);
				}
				if(map[i][j]=='G'){
					gx=j;
					gy=i;
				}
				if(map[i][j]=='X'&&maps[i][j]==0){
					v.x=j;
					v.y=i;
					q.push(v);
					while(!q.empty()){
						v=q.front();
						q.pop();
						maps[v.y][v.x]=nc;
						ig[nc]++;
						for(k=0;k<4;k++){
							u=v;
							u.x+=mx[k];
							u.y+=my[k];
							if(map[u.y][u.x]=='X'&&maps[u.y][u.x]==0&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly){
								q.push(u);
								
							}
						}
					}
					if(ig[nc]==1){
						map[v.y][v.x]='#';
					}
					nc++;
					
				}
			}
		}
		v.x=gx;
		v.y=gy;
		
		memset(f,-1,sizeof(f));
		f[gy][gx]=0;
		q.push(v);
		while(!q.empty()){
			v=q.front();
			q.pop();
			for(i=0;i<4;i++){
				u=v;
				u.x+=mx[i];
				u.y+=my[i];
				if(map[u.y][u.x]!='#'&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly&&f[u.y][u.x]==-1){
					q.push(u);
					f[u.y][u.x]=f[v.y][v.x]+1;
				}
			}
		}

		while(!s.empty()){
			r=s.top();
			s.pop();
			if(r.visited[r.y][r.x]==1){
				continue;
			}
			else{
				r.visited[r.y][r.x]=1;
			}
			if(r.cnt+f[r.y][r.x]>=min){
				continue;
			}
			
			for(i=0;i<4;i++){
				t=r;
				t.x+=mx[i];
				t.y+=my[i];
				t.cnt++;
				if(map[t.y][t.x]!='#'&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					
				if(mapc[t.y][t.x]>r.cnt+1||mapc[t.y][t.x]==-1){
						mapc[t.y][t.x]=r.cnt+1;
					}
					else{
						if(mapc[t.y][t.x]<=r.cnt){
						continue;
						}
					}
				if(map[t.y][t.x]=='G'&&t.cnt<min&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					ex=t.x;
					ey=t.y;
					min=t.cnt;
					break;
				}
				else if(r.visited[t.y][t.x]==0){
					
					if(map[t.y][t.x]=='X'){
						a=maps[t.y][t.x];
						t.ic[a]++;
						if(t.ic[a]<=(ig[a]/2)){
							s.push(t);
						}
					}
					else{
						s.push(t);
					}
				}
				}
			}
		}
		cout<<mapc[ey][ex]<<endl;
	}
	return 0;
}
accuracy: 0.8
time_ms: 10
memory_kb: 5660
final_rank: 18

code_snippet: #include<iostream>
#include<stack>
#include<queue>
#include<cstring>
#define INF 1 << 15
using namespace std;
struct d{
	int x;
	int y;
	int visited[12][12];
	int ic[144];
	int cnt;
};
struct b{
	int x;
	int y;
};
int main(){
	int lx,ly,i,j,nc=1,k,a,min=144,gx,gy,ex,ey;
	int maps[12][12]={0};
	int mx[4]={-1,0,1,0};
	int my[4]={0,-1,0,1};
	int ig[144]={0};
	int f[12][12];
	int mapc[13][13];
	char map[13][13];
	queue<b> q;
	b v,u;
	stack<d> s;
	d r,t;
	while(1){
		cin>>lx>>ly;
			if(lx==0&&ly==0){
				break;
			}
				memset(mapc,-1,sizeof(mapc));
			nc=1;
			memset(maps,0,sizeof(maps));
			memset(ig,0,sizeof(ig));
			min=144;
		for(i=0;i<ly;i++){
			cin>>map[i];
		}
		for(i=0;i<ly;i++){
			for(j=0;j<lx;j++){
					if(map[i][j]=='S'){
					r.x=j;
						r.y=i;
					memset(r.visited,0,sizeof(r.visited));
					memset(r.ic,0,sizeof(r.ic));
					r.cnt=0;
						mapc[i][j]=0;
					s.push(r);
				}
				if(map[i][j]=='G'){
					gx=j;
					gy=i;
				}
				if(map[i][j]=='X'&&maps[i][j]==0){
					v.x=j;
					v.y=i;
					q.push(v);
					while(!q.empty()){
						v=q.front();
						q.pop();
						maps[v.y][v.x]=nc;
						ig[nc]++;
						for(k=0;k<4;k++){
							u=v;
							u.x+=mx[k];
							u.y+=my[k];
							if(map[u.y][u.x]=='X'&&maps[u.y][u.x]==0&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly){
								q.push(u);
								
							}
						}
					}
					if(ig[nc]==1){
						map[v.y][v.x]='#';
					}
					nc++;
					
				}
			}
		}
		v.x=gx;
		v.y=gy;
		
		memset(f,-1,sizeof(f));
		f[gy][gx]=0;
		q.push(v);
		while(!q.empty()){
			v=q.front();
			q.pop();
			for(i=0;i<4;i++){
				u=v;
				u.x+=mx[i];
				u.y+=my[i];
				if(map[u.y][u.x]!='#'&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly&&f[u.y][u.x]==-1){
					q.push(u);
					f[u.y][u.x]=f[v.y][v.x]+1;
				}
			}
		}

		while(!s.empty()){
			r=s.top();
			s.pop();
			if(r.visited[r.y][r.x]==1){
				continue;
			}
			else{
				r.visited[r.y][r.x]=1;
			}
			if(r.cnt+f[r.y][r.x]>=min){
				continue;
			}
			
			for(i=0;i<4;i++){
				t=r;
				t.x+=mx[i];
				t.y+=my[i];
				t.cnt++;
				if(map[t.y][t.x]!='#'&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					
				if(mapc[t.y][t.x]>r.cnt+1||mapc[t.y][t.x]==-1){
						mapc[t.y][t.x]=r.cnt+1;
					}
					else{
						if(mapc[t.y][t.x]<r.cnt){
						continue;
						}
					}
				if(map[t.y][t.x]=='G'&&t.cnt<min&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					ex=t.x;
					ey=t.y;
					min=t.cnt;
					break;
				}
				else if(r.visited[t.y][t.x]==0){
					
					if(map[t.y][t.x]=='X'){
						a=maps[t.y][t.x];
						t.ic[a]++;
						if(t.ic[a]<=(ig[a]/2)){
							s.push(t);
						}
					}
					else{
						s.push(t);
					}
				}
				}
			}
		}
		cout<<mapc[ey][ex]<<endl;
	}
	return 0;
}
accuracy: 0.8
time_ms: 10
memory_kb: 5796
final_rank: 20

code_snippet: #include<iostream>
#include<stack>
#include<queue>
#include<cstring>
#define INF 1 << 15
using namespace std;
struct d{
	int x;
	int y;
	int visited[12][12];
	int ic[144];
	int cnt;
};
struct b{
	int x;
	int y;
};
int main(){
	int lx,ly,i,j,nc=1,k,a,min=144,gx,gy;
	int maps[12][12]={0};
	int mx[4]={-1,0,1,0};
	int my[4]={0,-1,0,1};
	int ig[144]={0};
	int f[12][12];
	int mapc[12][12];
	char map[13][13];
	queue<b> q;
	b v,u;
	stack<d> s;
	d r,t;
	while(1){
		cin>>lx>>ly;
			if(lx==0&&ly==0){
				break;
			}
				memset(mapc,-1,sizeof(mapc));
			nc=1;
			memset(maps,0,sizeof(maps));
			memset(ig,0,sizeof(ig));
			min=144;
		for(i=0;i<ly;i++){
			cin>>map[i];
		}
		for(i=0;i<ly;i++){
			for(j=0;j<lx;j++){
					if(map[i][j]=='S'){
					r.x=j;
						r.y=i;
					memset(r.visited,0,sizeof(r.visited));
					memset(r.ic,0,sizeof(r.ic));
					r.cnt=0;
						mapc[i][j]=0;
					s.push(r);
				}
				if(map[i][j]=='G'){
					gx=j;
					gy=i;
				}
				if(map[i][j]=='X'&&maps[i][j]==0){
					v.x=j;
					v.y=i;
					q.push(v);
					while(!q.empty()){
						v=q.front();
						q.pop();
						maps[v.y][v.x]=nc;
						ig[nc]++;
						for(k=0;k<4;k++){
							u=v;
							u.x+=mx[k];
							u.y+=my[k];
							if(map[u.y][u.x]=='X'&&maps[u.y][u.x]==0&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly){
								q.push(u);
								
							}
						}
					}
					if(ig[nc]==1){
						map[v.y][v.x]='#';
					}
					nc++;
					
				}
			}
		}
		v.x=gx;
		v.y=gy;
		
		memset(f,-1,sizeof(f));
		f[gy][gx]=0;
		q.push(v);
		while(!q.empty()){
			v=q.front();
			q.pop();
			for(i=0;i<4;i++){
				u=v;
				u.x+=mx[i];
				u.y+=my[i];
				if(map[u.y][u.x]!='#'&&u.x>=0&&u.x<lx&&u.y>=0&&u.y<ly&&f[u.y][u.x]==-1){
					q.push(u);
					f[u.y][u.x]=f[v.y][v.x]+1;
				}
			}
		}

		while(!s.empty()){
			r=s.top();
			s.pop();
			if(r.visited[r.y][r.x]==1){
				continue;
			}
			else{
				r.visited[r.y][r.x]=1;
			}
			if(r.cnt+f[r.y][r.x]>=min){
				continue;
			}
			/*
			if(map[r.y][r.x]=='X'){
				a=maps[r.y][r.x];
				r.ic[a]++;
				if(r.ic[a]>(ig[a]/2)){
					continue;
				}
			}*/
			for(i=0;i<4;i++){
				t=r;
				t.x+=mx[i];
				t.y+=my[i];
				t.cnt++;
				if(map[t.y][t.x]=='G'&&t.cnt<min&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly){
					min=t.cnt;
					break;
				}
				else if(map[t.y][t.x]!='#'&&t.x>=0&&t.x<lx&&t.y>=0&&t.y<ly&&r.visited[t.y][t.x]==0){
					if(mapc[t.y][t.x]>r.cnt+1||mapc[t.y][t.x]==-1){
						mapc[t.y][t.x]=r.cnt+1;
					}
					else{
						if(mapc[t.y][t.x]<r.cnt){
						continue;
						}
					}
					if(map[t.y][t.x]=='X'){
						a=maps[t.y][t.x];
						t.ic[a]++;
						if(t.ic[a]<=(ig[a]/2)){
							s.push(t);
						}
					}
					else{
						s.push(t);
					}
				}
			}
		}
		cout<<min<<endl;
	}
	return 0;
}
accuracy: 0.8
time_ms: 10
memory_kb: 5704
final_rank: 19