stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<queue>

#include<utility>

#include<cstring>

using namespace std;

char map[1005][1005];

bool vis[1005][1005];

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

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

int sx,sy;

int h,w;

int bfs(int n){

	memset(vis,false,sizeof(vis));

	queue<pair<pair<int,int>,int> >que;

	que.push(make_pair(make_pair(sx,sy),0));

	while(!que.empty()){

		pair<int,int>now=que.front().first;

		int cnt=que.front().second;

		que.pop();

		if(map[now.first][now.second]==n+48){

			sx=now.first;

			sy=now.second;

			return cnt;

		}

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

			int _x=now.first+dx[i];

			int _y=now.second+dy[i];

			if(_x<0||_y<0||_x>=h||_y>=w||map[_x][_y]=='X'||vis[_x][_y]){

				continue;

			}

			vis[_x][_y]=true;

			que.push(make_pair(make_pair(_x,_y),cnt+1));

		}

	}

}

int main(){

	int n;

	while(cin>>h>>w>>n){

		memset(map,0,sizeof(map));

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

			scanf("%s",map[i]);

		}

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

			for(int j=0;j<w;j++){

				if(map[i][j]=='S'){

					sx=i;

					sy=j;

					map[i][j]=='.';

					break;

				}

			}

		}

		int count=0;

		for(int k=1;k<=n;k++){

			count+=bfs(k);

		}

		cout<<count<<endl;

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.004017936833718x):
#include<iostream>

#include<iomanip>

#include<cstdlib>

#include<math.h>

#include<algorithm>

#include<string>

#include<vector>

#include<list>

#include<queue>

#include<stack>

#include<deque>

#include<set>

#include<map>

#define REP(i, N) for(ll i = 0; i < N; ++i)

#define FOR(i, a, b) for(ll i = a; i < b; ++i)

#define ALL(a) (a).begin(),(a).end()

#define pb push_back

#define INF 1000000000

#define MOD 1000000007

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

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

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

int qx[8] = {1, 1, 0, -1, -1, -1, 0, 1};

int qy[8] = {0, 1, 1, 1, 0, -1, -1, -1};



int main(void) {

	ll h, w, n;

	cin>>h>>w>>n;

	vector<string> a(h);

	vector<vector<ll> > dist(h, vector<ll>(w, INF));

	ll time = 0;

	P sp;

	REP(i, h) cin>>a[i];

	bool det = false;

	REP(i, h) {

		REP(j, w) {

			if(a[i][j] == 'S') {

				sp.first = i;

				sp.second = j;

				det = true;

				break;

			}

		}

		if(det) break;

	}

	REP(i, n) {

		queue<P> c;

		c.push(sp);

		dist[sp.first][sp.second] = 0;

		while(true) {

			P cp = c.front();

			c.pop();

			if(a[cp.first][cp.second] - '1' == i) {

				time += dist[cp.first][cp.second];

				sp = cp;

				break;

			}

			REP(j, 4) {

				ll nx = cp.first + dx[j];

				ll ny = cp.second + dy[j];

				if(nx >= 0 && nx < h && ny >= 0 && ny < w && dist[nx][ny] == INF && (a[nx][ny] == 'S' || a[nx][ny] == '.' || (a[nx][ny] >= '1' && a[nx][ny] <= '9'))) {

					c.push(P(nx, ny));

					dist[nx][ny] = dist[cp.first][cp.second] + 1;

				}

			}

		}

		REP(j, h) {

			REP(k, w) {

				dist[j][k] = INF;

			}

		}

	}

	cout<<time<<endl;

}
// Slower C++ solution:
#include<stdio.h>

#include<string.h>

#include<queue>

#include<algorithm>

#define MAX_N 1002

using namespace std;

struct node{int x,y;};

char _map[MAX_N][MAX_N];

int dp[MAX_N][MAX_N];

int ox[]={0,0,1,-1};

int oy[]={1,-1,0,0};

int S_x,S_y;

int h,w,cnt;



node make_node(int x,int y){

	node t;

	t.x=x,t.y=y;

	return t;

}

void solve(){

	queue<node> que;

	int step=0;

	

	for(int i=1;i<=cnt;i++){

		que.push(make_node(S_x,S_y));

		_map[S_x][S_y]='.';

		memset(dp,-1,sizeof(dp));

		dp[S_x][S_y]=step;

		while(!que.empty()){

			node t=que.front();que.pop();

			if(_map[t.x][t.y]=='0'+i){

				step=dp[t.x][t.y];

				S_x=t.x,S_y=t.y;

				break;

			}

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

				int x=t.x+ox[j];

				int y=t.y+oy[j];

				if(0<=x&&x<h&&0<=y&&y<w&&_map[x][y]!='X'&&dp[x][y]==-1){

					que.push(make_node(x,y));

					dp[x][y]=dp[t.x][t.y]+1;

				}

			}

		}

		while(!que.empty()) que.pop();

	}

	

	printf("%d\n",step);

}



int main()

{

	while(scanf("%d%d%d",&h,&w,&cnt)!=EOF){

		for(int i=0;i<h;i++)

			scanf("%s",_map[i]);

		for(int j=0;j<h;j++)

			for(int k=0;k<w;k++)

				if(_map[j][k]=='S')

					S_x=j,S_y=k,j=h,k=w;

		solve();

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.960748208647987x):
#include<iostream>

#include<iomanip>

#include<cstdlib>

#include<math.h>

#include<algorithm>

#include<string>

#include<vector>

#include<list>

#include<queue>

#include<stack>

#include<deque>

#include<set>

#include<map>

#define REP(i, N) for(ll i = 0; i < N; ++i)

#define FOR(i, a, b) for(ll i = a; i < b; ++i)

#define ALL(a) (a).begin(),(a).end()

#define pb push_back

#define INF 1000000000

#define MOD 1000000007

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

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

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

int qx[8] = {1, 1, 0, -1, -1, -1, 0, 1};

int qy[8] = {0, 1, 1, 1, 0, -1, -1, -1};



int main(void) {

	ll h, w, n;

	cin>>h>>w>>n;

	vector<string> a(h);

	vector<vector<ll> > dist(h, vector<ll>(w, INF));

	ll time = 0;

	P sp;

	REP(i, h) cin>>a[i];

	bool det = false;

	REP(i, h) {

		REP(j, w) {

			if(a[i][j] == 'S') {

				sp.first = i;

				sp.second = j;

				det = true;

				break;

			}

		}

		if(det) break;

	}

	REP(i, n) {

		queue<P> c;

		c.push(sp);

		dist[sp.first][sp.second] = 0;

		while(true) {

			P cp = c.front();

			c.pop();

			if(a[cp.first][cp.second] - '1' == i) {

				time += dist[cp.first][cp.second];

				sp = cp;

				break;

			}

			REP(j, 4) {

				ll nx = cp.first + dx[j];

				ll ny = cp.second + dy[j];

				if(nx >= 0 && nx < h && ny >= 0 && ny < w && dist[nx][ny] == INF && (a[nx][ny] == 'S' || a[nx][ny] == '.' || (a[nx][ny] >= '1' && a[nx][ny] <= '9'))) {

					c.push(P(nx, ny));

					dist[nx][ny] = dist[cp.first][cp.second] + 1;

				}

			}

		}

		REP(j, h) {

			REP(k, w) {

				dist[j][k] = INF;

			}

		}

	}

	cout<<time<<endl;

}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<queue>

#include<utility>

#include<cstring>

using namespace std;

char map[1005][1005];

bool vis[1005][1005];

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

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

int sx,sy;

int h,w;

int bfs(int n){

	memset(vis,false,sizeof(vis));

	queue<pair<pair<int,int>,int> >que;

	que.push(make_pair(make_pair(sx,sy),0));

	while(!que.empty()){

		pair<int,int>now=que.front().first;

		int cnt=que.front().second;

		que.pop();

		if(map[now.first][now.second]==n+48){

			sx=now.first;

			sy=now.second;

			return cnt;

		}

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

			int _x=now.first+dx[i];

			int _y=now.second+dy[i];

			if(_x<0||_y<0||_x>=h||_y>=w||map[_x][_y]=='X'||vis[_x][_y]){

				continue;

			}

			vis[_x][_y]=true;

			que.push(make_pair(make_pair(_x,_y),cnt+1));

		}

	}

}

int main(){

	int n;

	while(cin>>h>>w>>n){

		memset(map,0,sizeof(map));

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

			scanf("%s",map[i]);

		}

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

			for(int j=0;j<w;j++){

				if(map[i][j]=='S'){

					sx=i;

					sy=j;

					map[i][j]=='.';

					break;

				}

			}

		}

		int count=0;

		for(int k=1;k<=n;k++){

			count+=bfs(k);

		}

		cout<<count<<endl;

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.915291495573534x):
#include <iostream>

#include <queue>

#include <string>



using namespace std;



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

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

int First = 1000;

int w,h,n;

int ans = 0;

int d[1001][1001];

typedef struct p{

	int x, y;

}P;

string mapp[1001];

P nezumi[11];





//幅優先探索を行う

void bfs(){

	for(int i=1 ; i <= n ; i++ ){

		P sp = nezumi[i-1];

		int sx = nezumi[i-1].x;

		int sy = nezumi[i-1].y;

		int gx = nezumi[i].x;

		int gy = nezumi[i].y;



		//二次元配列の初期化をする

		for(int y=0 ; y < h ; y++ ){

			for(int x=0 ; x < w ; x++ ){

				d[y][x] = First;

			}

		}

		

		queue<P> q;

		q.push( sp );

		d[sy][sx] = 0;

		while( !q.empty() ){

			P now = q.front();

			q.pop();

			int x = now.x;

			int y = now.y;



			if( x == gx && y == gy ){

				ans += d[gy][gx];



				/*動作確認

				cout << "\n";

				for(int y=0 ; y < h ; y++ ){

					for(int x=0 ; x < w ; x++ ){

						if (d[y][x]==First){cout << "X";}

							else{cout << d[y][x];}

					}

					cout << "\n";

				}*/

				break;

			}



			//redandblackと同じように探索

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

				int newx = x + dx[i];

				int newy = y + dy[i];

				if( newx < 0 || newy < 0 || newx >= w || newy >= h ) continue;

				if( mapp[newy][newx] != 'X' ){

					P next;

					next.x = newx;

					next.y = newy;

					if( d[newy][newx] == First ){

						d[newy][newx] = d[y][x] + 1;

						q.push( next );

					}

				}

			}

		}

	}

}



int main(){

	//標準入力

	cin >> h >> w >> n;

	for(int y=0 ; y < h ; y++ ){

		cin >> mapp[y];

	}

	

	//スタートと数字の確認

	for(int y=0 ; y < h ; y++ ){

		for(int x=0 ; x < w ; x++ ){

			char c = mapp[y][x];



			//アスキー使っていい感じにしてみる

			if( c >= '1' && c <= '9' ){

				nezumi[ c - '0' ].x = x;

				nezumi[ c - '0' ].y = y;

			}

			if(c == 'S'){

				nezumi[0].x = x;

				nezumi[0].y = y;

			}

		}

	}

	bfs();

	cout << ans << endl;

}
// Slower C++ solution:
#include<stdio.h>

#include<string.h>

#include<queue>

#include<algorithm>

#define MAX_N 1002

using namespace std;

struct node{int x,y;};

char _map[MAX_N][MAX_N];

int dp[MAX_N][MAX_N];

int ox[]={0,0,1,-1};

int oy[]={1,-1,0,0};

int S_x,S_y;

int h,w,cnt;



node make_node(int x,int y){

	node t;

	t.x=x,t.y=y;

	return t;

}

void solve(){

	queue<node> que;

	int step=0;

	

	for(int i=1;i<=cnt;i++){

		que.push(make_node(S_x,S_y));

		_map[S_x][S_y]='.';

		memset(dp,-1,sizeof(dp));

		dp[S_x][S_y]=step;

		while(!que.empty()){

			node t=que.front();que.pop();

			if(_map[t.x][t.y]=='0'+i){

				step=dp[t.x][t.y];

				S_x=t.x,S_y=t.y;

				break;

			}

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

				int x=t.x+ox[j];

				int y=t.y+oy[j];

				if(0<=x&&x<h&&0<=y&&y<w&&_map[x][y]!='X'&&dp[x][y]==-1){

					que.push(make_node(x,y));

					dp[x][y]=dp[t.x][t.y]+1;

				}

			}

		}

		while(!que.empty()) que.pop();

	}

	

	printf("%d\n",step);

}



int main()

{

	while(scanf("%d%d%d",&h,&w,&cnt)!=EOF){

		for(int i=0;i<h;i++)

			scanf("%s",_map[i]);

		for(int j=0;j<h;j++)

			for(int k=0;k<w;k++)

				if(_map[j][k]=='S')

					S_x=j,S_y=k,j=h,k=w;

		solve();

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.814227933537681x):
#include <iostream>

#include <queue>

#include <string>



using namespace std;



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

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

int First = 1000;

int w,h,n;

int ans = 0;

int d[1001][1001];

typedef struct p{

	int x, y;

}P;

string mapp[1001];

P nezumi[11];





//幅優先探索を行う

void bfs(){

	for(int i=1 ; i <= n ; i++ ){

		P sp = nezumi[i-1];

		int sx = nezumi[i-1].x;

		int sy = nezumi[i-1].y;

		int gx = nezumi[i].x;

		int gy = nezumi[i].y;



		//二次元配列の初期化をする

		for(int y=0 ; y < h ; y++ ){

			for(int x=0 ; x < w ; x++ ){

				d[y][x] = First;

			}

		}

		

		queue<P> q;

		q.push( sp );

		d[sy][sx] = 0;

		while( !q.empty() ){

			P now = q.front();

			q.pop();

			int x = now.x;

			int y = now.y;



			if( x == gx && y == gy ){

				ans += d[gy][gx];



				/*動作確認

				cout << "\n";

				for(int y=0 ; y < h ; y++ ){

					for(int x=0 ; x < w ; x++ ){

						if (d[y][x]==First){cout << "X";}

							else{cout << d[y][x];}

					}

					cout << "\n";

				}*/

				break;

			}



			//redandblackと同じように探索

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

				int newx = x + dx[i];

				int newy = y + dy[i];

				if( newx < 0 || newy < 0 || newx >= w || newy >= h ) continue;

				if( mapp[newy][newx] != 'X' ){

					P next;

					next.x = newx;

					next.y = newy;

					if( d[newy][newx] == First ){

						d[newy][newx] = d[y][x] + 1;

						q.push( next );

					}

				}

			}

		}

	}

}



int main(){

	//標準入力

	cin >> h >> w >> n;

	for(int y=0 ; y < h ; y++ ){

		cin >> mapp[y];

	}

	

	//スタートと数字の確認

	for(int y=0 ; y < h ; y++ ){

		for(int x=0 ; x < w ; x++ ){

			char c = mapp[y][x];



			//アスキー使っていい感じにしてみる

			if( c >= '1' && c <= '9' ){

				nezumi[ c - '0' ].x = x;

				nezumi[ c - '0' ].y = y;

			}

			if(c == 'S'){

				nezumi[0].x = x;

				nezumi[0].y = y;

			}

		}

	}

	bfs();

	cout << ans << endl;

}
// Slower C++ solution:
#include"stdio.h"

#include"stdlib.h"

#include"string.h"

#include"algorithm"

#include"queue"

using namespace std;

struct mmm

{

	int x,y;

}vv;

int dir[4][2] = {0,-1,-1,0,0,1,1,0};

char xx[1005][1005];

int bb[11][2];

queue <mmm> qq;

int vis[1005][1005];

int bfs(char t)

{

	int sum = 0;

	int pl = 0;

	while(!qq.empty())

	{

		vv = qq.front();

		int x0 = vv.x;

		int y0 = vv.y;

		//printf("%d %d %d\n",x0,y0,vis[x0][y0]);

		qq.pop();

		if(xx[x0][y0] == t && !pl)

		{

			sum = vis[x0][y0];

			pl = 1;

		}

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

		{

			int xt = x0 + dir[i][0];

			int yt = y0 + dir[i][1];

			if(xx[xt][yt] != '#' && xx[xt][yt] != 'X' && vis[xt][yt] == -1)

			{

				vis[xt][yt] = vis[x0][y0] + 1;

				vv.x = xt;

				vv.y = yt;

				qq.push(vv);

			}

		}

	}

	return sum;

}

int main()

{

	int a,b,c,d,x1,y1,sum;

	while(~scanf("%d %d %d",&a,&b,&c))

	{

	//	if(a == 0 && b == 0)

	//	break;

		memset(xx,'#',sizeof(xx));

		getchar();

		for(int i = 1;i <= a;i++)

		{

			for(int j = 1;j <= b;j++)

			{

				xx[i][j] = getchar();

				if(xx[i][j] == 'S')

				{

					x1 = i;

					y1 = j;

				}

				else if(xx[i][j] != 'X')

				{

					bb[xx[i][j] - '0'][0] = i;

					bb[xx[i][j] - '0'][1] = j;

				}

			}

			getchar();

		}

		bb[0][0] = x1;

		bb[0][1] = y1;

		sum = 0;

		for(int i = 1;i <= c;i++)

		{

			vv.x = bb[i-1][0];

			vv.y = bb[i-1][1];

			memset(vis,-1,sizeof(vis));

			vis[vv.x][vv.y] = 0;

			qq.push(vv);

			sum += bfs(i + '0');

		}

		printf("%d\n",sum);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.0061399983735346x):
#include<queue>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define SC(x) scanf("%d",&x);

#define pr(x)  cout << x << endl;

#define mem(arr,v) memset(arr,v,sizeof arr);

#define bug(x) cout << "#x = " << x <<endl;

const int inf = 0x3f3f3f3f;

const int maxn = 1010;

typedef long long ll;

using namespace std;

char Mz[maxn][maxn],c;

bool vis[maxn][maxn];

int dir[4][2] = {1,0,-1,0,0,1,0,-1};

int M,N,C;

int px[10],py[10];

struct node {

	int x,y,step;

};



int bfs(int des,int sx,int sy) {

	mem(vis,0);

	vis[sx][sy] = 1;

	node nod = {sx,sy,0};

	queue<node> q;

	q.push(nod);



	while(!q.empty()) {

		nod =  q.front();

		q.pop();

		

		int x = nod.x, y = nod.y;

		int step =  nod.step;

		

		if(Mz[x][y] == des + '0')

			return step;

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

			int dx = x + dir[i][0];

			int dy = y + dir[i][1];

			if(Mz[dx][dy] == 'X' || Mz[dx][dy] == -1 || vis[dx][dy])	continue;

			nod = {dx,dy,step + 1};

			q.push(nod);

			vis[dx][dy] = 1;

		}

	}

}



int main() {

//	freopen("in.txt","r",stdin);

	cin >> N >> M >> C;

	mem(Mz,-1)

	mem(px,0)  mem(py,0)



	for(int i = 1 ; i <= N ; i++)

		for(int j = 1; j <= M ; j++) {

			cin >> c;

			Mz[i][j] = c;

			if(c == '.' || c == 'X')	continue;

			if(c == 'S') px[0] = i, py[0] = j;

			else

				px[c - '0'] = i , py[c - '0'] = j;

		}

	int res = 0;

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

		if(px[i] && py[i]) {

//				dfs(i + 1,px[i],py[i],0);

			res += bfs(i + 1,px[i],py[i]);

		}

	}

	printf("%d\n",res);

}
// Slower C++ solution:
/*

*

*/

#include<iostream>

#include<cstring>

#include<cstdio>

#include<cmath>

#include<string>

#include<queue>

#define CLR(ARR,NUM) memset(ARR,NUM,sizeof(ARR))

#define GETNUM(NUM) scanf("%d",&NUM)

#define faster_io() ios_base::sync_with_stdio(false)

using namespace std;

const int MAXN = 1010;

char map[MAXN][MAXN];

bool vis[10][MAXN][MAXN];

struct node{

	int x;

	int y;

	int deep;

	int n;

};

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

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



int main()

{

	CLR(vis,false);

	CLR(map,'X');

	int h,w,n;

	cin >> h >> w >> n;

	getchar();

	int sx,sy;

	for(int i=1;i<=h;i++){

		for(int j=1;j<=w;j++){

			map[i][j]=getchar();

			if(map[i][j]=='S'){

				sx=i;

				sy=j;

			}

		}

		getchar();

	}

	node t;

	t.x=sx;

	t.y=sy;

	t.deep=0;

	t.n=0;

	queue<node>q;

	vis[0][sx][sy]=true;

	q.push(t);

	int ans = -1;

	while(!q.empty()){

		node cur=q.front();

		if(cur.n==n){

			ans=cur.deep;

			break;

		}

		q.pop();

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

			int tx=cur.x+dx[i];

			int ty=cur.y+dy[i];

			if(map[tx][ty]!='X'&&!vis[cur.n][tx][ty]){

				node t = cur;

				t.x=tx;

				t.y=ty;

				t.deep++;

				if(map[tx][ty]=='1'+t.n){

					t.n++;

				}

				vis[t.n][tx][ty]=true;

				q.push(t);

			}

		}

	}

	cout << ans << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.219580335300965x):
#include<queue>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define SC(x) scanf("%d",&x);

#define pr(x)  cout << x << endl;

#define mem(arr,v) memset(arr,v,sizeof arr);

#define bug(x) cout << "#x = " << x <<endl;

const int inf = 0x3f3f3f3f;

const int maxn = 1010;

typedef long long ll;

using namespace std;

char Mz[maxn][maxn],c;

bool vis[maxn][maxn];

int dir[4][2] = {1,0,-1,0,0,1,0,-1};

int M,N,C;

int px[10],py[10];

struct node {

	int x,y,step;

};



int bfs(int des,int sx,int sy) {

	mem(vis,0);

	vis[sx][sy] = 1;

	node nod = {sx,sy,0};

	queue<node> q;

	q.push(nod);



	while(!q.empty()) {

		nod =  q.front();

		q.pop();

		

		int x = nod.x, y = nod.y;

		int step =  nod.step;

		

		if(Mz[x][y] == des + '0')

			return step;

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

			int dx = x + dir[i][0];

			int dy = y + dir[i][1];

			if(Mz[dx][dy] == 'X' || Mz[dx][dy] == -1 || vis[dx][dy])	continue;

			nod = {dx,dy,step + 1};

			q.push(nod);

			vis[dx][dy] = 1;

		}

	}

}



int main() {

//	freopen("in.txt","r",stdin);

	cin >> N >> M >> C;

	mem(Mz,-1)

	mem(px,0)  mem(py,0)



	for(int i = 1 ; i <= N ; i++)

		for(int j = 1; j <= M ; j++) {

			cin >> c;

			Mz[i][j] = c;

			if(c == '.' || c == 'X')	continue;

			if(c == 'S') px[0] = i, py[0] = j;

			else

				px[c - '0'] = i , py[c - '0'] = j;

		}

	int res = 0;

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

		if(px[i] && py[i]) {

//				dfs(i + 1,px[i],py[i],0);

			res += bfs(i + 1,px[i],py[i]);

		}

	}

	printf("%d\n",res);

}
// Slower C++ solution:
#include <queue>

#include <cstring>

#include <iostream>

using namespace std;



const int N = 1111;

const int cx[] = {0, 0, 1, -1}, cy[] = {1, -1, 0, 0};

char maze[N][N];

int step[N][N];

int h, w, n, sx, sy, ans;



int bfs(int cheese){

    memset(step, -1, sizeof(step));

    queue<pair<int, int> > que;

    que.push(make_pair(sx, sy));

    step[sx][sy] = 0;

    while(!que.empty()){

        int x = que.front().first, y = que.front().second;

        que.pop();

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

            int nx = x + cx[i], ny = y + cy[i];

            if(nx < 0 || h <= nx || ny < 0 || w <= ny || maze[nx][ny] == 'X' || step[nx][ny] != -1) continue;

            step[nx][ny] = step[x][y] + 1;

            if(maze[nx][ny] - '0' == cheese){

                sx = nx;

                sy = ny;

                return step[nx][ny];

            }

            que.push(make_pair(nx, ny));

        }

    }

    return 0;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(NULL);

    while(cin >> h >> w >> n){

        for(int i = 0; i < h; ++i)

            for(int j = 0; j < w; ++j){

                cin >> maze[i][j];

                if(maze[i][j] == 'S'){

                    sx = i;

                    sy = j;

                }

            }

        ans = 0;

        for(int i = 1; i <= n; ++i)

            ans += bfs(i);

        cout << ans << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.0051669581361x):
#include<queue>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define SC(x) scanf("%d",&x);

#define pr(x)  cout << x << endl;

#define mem(arr,v) memset(arr,v,sizeof arr);

#define bug(x) cout << "#x = " << x <<endl;

const int inf = 0x3f3f3f3f;

const int maxn = 1010;

typedef long long ll;

using namespace std;

char Mz[maxn][maxn],c;

bool vis[maxn][maxn];

int dir[4][2] = {1,0,-1,0,0,1,0,-1};

int M,N,C;

int px[10],py[10];

struct node {

	int x,y,step;

};



int bfs(int des,int sx,int sy) {

	mem(vis,0);

	vis[sx][sy] = 1;

	node nod = {sx,sy,0};

	queue<node> q;

	q.push(nod);



	while(!q.empty()) {

		nod =  q.front();

		q.pop();

		

		int x = nod.x, y = nod.y;

		int step =  nod.step;

		

		if(Mz[x][y] == des + '0')

			return step;

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

			int dx = x + dir[i][0];

			int dy = y + dir[i][1];

			if(Mz[dx][dy] == 'X' || Mz[dx][dy] == -1 || vis[dx][dy])	continue;

			nod = {dx,dy,step + 1};

			q.push(nod);

			vis[dx][dy] = 1;

		}

	}

}



int main() {

//	freopen("in.txt","r",stdin);

	cin >> N >> M >> C;

	mem(Mz,-1)

	mem(px,0)  mem(py,0)



	for(int i = 1 ; i <= N ; i++)

		for(int j = 1; j <= M ; j++) {

			cin >> c;

			Mz[i][j] = c;

			if(c == '.' || c == 'X')	continue;

			if(c == 'S') px[0] = i, py[0] = j;

			else

				px[c - '0'] = i , py[c - '0'] = j;

		}

	int res = 0;

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

		if(px[i] && py[i]) {

//				dfs(i + 1,px[i],py[i],0);

			res += bfs(i + 1,px[i],py[i]);

		}

	}

	printf("%d\n",res);

}