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

#include<cstring>

#include<queue>

using namespace std;

int map[1005][1005];

struct node{

	int x,y,time;

}s[10],p;

queue<node> q;

int vis[1005][1005];

int n,m,T;

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

int bfs(int a,int b){

	while(!q.empty())

		q.pop();

	q.push(s[a]);

	memset(vis,0,sizeof vis);

	vis[s[a].x][s[a].y]=1;

	while(!q.empty()){

		p=q.front();

		q.pop();

		int x=p.x,y=p.y,time=p.time;

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

			int x1=x+dir[i][0],y1=y+dir[i][1];

			if(x1<=0||y1<=0||x1>n||y1>m||vis[x1][y1]||map[x1][y1])

				continue ;

			if(x1==s[b].x&&y1==s[b].y)

				return time+1;

			vis[x1][y1]=1;

			p.x=x1,p.y=y1,p.time=time+1;

			q.push(p);

		}

	}

}

int main()

{

	scanf("%d%d%d",&n,&m,&T);

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

		scanf("\n");

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

			char c;

			c=getchar();

			if(c=='S')

				s[0].x=i,s[0].y=j;

			if(c=='X')

				map[i][j]=1;

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

				s[c-'0'].x=i,s[c-'0'].y=j;

		}

	}

	int time=0;

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

		time+=bfs(i,i+1);

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

}

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

#include<algorithm>

#include<queue>

const int INF = 100000000;

using namespace std;

typedef pair<int, int> P;

char a[1005][1005];

int N, M;

int sx, sy;

int gx, gy;

int d[1005][1005];

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

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

int bfs()

{

	queue<P> que;

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

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

			d[i][j] = INF;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		P p = que.front();

		que.pop();

		if (p.first == gx&&p.second == gy)

			break;

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

		{

			int nx = p.first + dx[i];

			int ny = p.second + dy[i];

			if (nx >= 0 && nx < N&&ny >= 0 && ny < M&&a[nx][ny] != 'X'&&d[nx][ny] == INF)

			{

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

				d[nx][ny] = d[p.first][p.second] + 1;

			}

		}



	}

	return d[gx][gy];

}

int main(void)

{

	while (cin >> N >> M)

	{

		int n, sum = 0;

		cin >> n;

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

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

				cin >> a[i][j];

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

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

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

				{

					sx = j;

					sy = k;

				}

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

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

				if (a[j][k] == '1')

				{

					gx = j;

					gy = k;

				}

		sum += bfs();

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

		{

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

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

				{

					if (a[j][k] == (char)(i+49))

					{

						sx = j;

						sy = k;

					}

					if (a[j][k] == (char)(i+50))

					{

						gx = j;

						gy = k;

					}

				}

			sum += bfs();



		}

		cout << sum << endl;

	}

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <stack>

#include <utility>

#include <algorithm>

#include <sstream>

using namespace std;

typedef pair<int,int> P;



const int max_n=1000+10;

int h,w,n,sx,sy,dx[]={0,0,-1,1},dy[]={-1,1,0,0},d[max_n][max_n],ans;

char c[max_n][max_n];



void bfs(int x,int y,int m){

	if(m>n)return;

	queue<P> q;

	memset(d,0,sizeof(d));

	q.push(P(x,y));

	d[x][y]=1;

	while(!q.empty()){

		P p=q.front();

		q.pop();

		if(c[p.first][p.second]=='0'+m){

		    ans+=d[p.first][p.second]-1;

		    bfs(p.first,p.second,m+1);

		    return;

		}

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

			int tx=p.first+dx[i],ty=p.second+dy[i];

			if(tx>=0 && tx<h && ty>=0 && ty<w && c[tx][ty]!='X' && !d[tx][ty]){

				q.push(P(tx,ty));

				d[tx][ty]=d[p.first][p.second]+1;

			}

		}

	}

}



int main(){

    scanf("%d%d%d",&h,&w,&n);

    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;}

        }

    bfs(sx,sy,1);

    cout<<ans<<endl;

    return 0;

}

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

#include<algorithm>

#include<queue>

const int INF = 100000000;

using namespace std;

typedef pair<int, int> P;

char a[1005][1005];

int N, M;

int sx, sy;

int gx, gy;

int d[1005][1005];

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

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

int bfs()

{

	queue<P> que;

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

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

			d[i][j] = INF;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		P p = que.front();

		que.pop();

		if (p.first == gx&&p.second == gy)

			break;

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

		{

			int nx = p.first + dx[i];

			int ny = p.second + dy[i];

			if (nx >= 0 && nx < N&&ny >= 0 && ny < M&&a[nx][ny] != 'X'&&d[nx][ny] == INF)

			{

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

				d[nx][ny] = d[p.first][p.second] + 1;

			}

		}



	}

	return d[gx][gy];

}

int main(void)

{

	while (cin >> N >> M)

	{

		int n, sum = 0;

		cin >> n;

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

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

				cin >> a[i][j];

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

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

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

				{

					sx = j;

					sy = k;

				}

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

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

				if (a[j][k] == '1')

				{

					gx = j;

					gy = k;

				}

		sum += bfs();

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

		{

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

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

				{

					if (a[j][k] == (char)(i+49))

					{

						sx = j;

						sy = k;

					}

					if (a[j][k] == (char)(i+50))

					{

						gx = j;

						gy = k;

					}

				}

			sum += bfs();



		}

		cout << sum << endl;

	}

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

#include <cstdio>

#include <cstring>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <stack>

#include <utility>

#include <algorithm>

#include <sstream>

using namespace std;



struct Node{

	int x,y;

};



const int max_n=1000+10;

int h,w,n,dx[]={0,0,-1,1},dy[]={-1,1,0,0},d[max_n][max_n],ans;

Node sN;

char c[max_n][max_n];



void bfs(int m){

	if(m>n)return;

	queue<Node> q;

	memset(d,0,sizeof(d));

	q.push(sN);

	d[sN.x][sN.y]=1;

	while(!q.empty()){

		Node p=q.front();

		q.pop();

		

		if(c[p.x][p.y]=='0'+m){

		    ans+=d[p.x][p.y]-1;

		    sN.x=p.x;

		    sN.y=p.y;

		    return;

		}

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

			Node nN;

			nN.x=p.x+dx[i];

			nN.y=p.y+dy[i];

			if(nN.x>=0 && nN.x<h 

            && nN.y>=0 && nN.y<w 

		   	&& c[nN.x][nN.y]!='X' && !d[nN.x][nN.y]){

				q.push(nN);

				d[nN.x][nN.y]=d[p.x][p.y]+1;

			}

		}

	}

}



int main(){

    scanf("%d%d%d",&h,&w,&n);

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

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

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

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

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

            	sN.x=i;

            	sN.y=j;

            	break;

            }

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

    cout<<ans<<endl;

    return 0;

}

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

#include<algorithm>

#include<queue>

const int INF = 100000000;

using namespace std;

typedef pair<int, int> P;

char a[1005][1005];

int N, M;

int sx, sy;

int gx, gy;

int d[1005][1005];

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

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

int bfs()

{

	queue<P> que;

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

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

			d[i][j] = INF;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		P p = que.front();

		que.pop();

		if (p.first == gx&&p.second == gy)

			break;

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

		{

			int nx = p.first + dx[i];

			int ny = p.second + dy[i];

			if (nx >= 0 && nx < N&&ny >= 0 && ny < M&&a[nx][ny] != 'X'&&d[nx][ny] == INF)

			{

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

				d[nx][ny] = d[p.first][p.second] + 1;

			}

		}



	}

	return d[gx][gy];

}

int main(void)

{

	while (cin >> N >> M)

	{

		int n, sum = 0;

		cin >> n;

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

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

				cin >> a[i][j];

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

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

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

				{

					sx = j;

					sy = k;

				}

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

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

				if (a[j][k] == '1')

				{

					gx = j;

					gy = k;

				}

		sum += bfs();

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

		{

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

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

				{

					if (a[j][k] == (char)(i+49))

					{

						sx = j;

						sy = k;

					}

					if (a[j][k] == (char)(i+50))

					{

						gx = j;

						gy = k;

					}

				}

			sum += bfs();



		}

		cout << sum << endl;

	}

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

#include <queue>

#include <string>

using namespace std;

int main()

{

	int h,w,n;

	int sx,sy;

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

	string map[1001];

	int d[1001][1001];

	int x = 0;

	cin >> h >> w >> n;

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

	{

		cin >> map[i];

	}

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

	{

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

		{

			d[j][i] = -1;

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

			{

				sx = j;

				sy = i;

			}

		}

	}

	d[sx][sy] = 0;

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

	{

		queue< pair<int, int> > que;

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

		{

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

			{

				d[k][j] = -1;

			}

		}

		d[sx][sy] = 0;

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

		while(que.size())

		{

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

			que.pop();

			if((map[p.second][p.first] - '0') == (i+1))

			{

				sx = p.first;

				sy = p.second;

				x+=d[sx][sy];

				break;

			}

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

			{

				int nx = p.first + dx[j];

				int ny = p.second + dy[j];

				if(0 <= nx && nx < w && 0 <= ny && ny < h && map[ny][nx] != 'X' && d[nx][ny] == -1)

				{

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

					d[nx][ny] = d[p.first][p.second] + 1;

				}

			}

		}

	}

	cout << x << endl;

}

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

#include<algorithm>

#include<queue>

const int INF = 100000000;

using namespace std;

typedef pair<int, int> P;

char a[1005][1005];

int N, M;

int sx, sy;

int gx, gy;

int d[1005][1005];

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

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

int bfs()

{

	queue<P> que;

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

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

			d[i][j] = INF;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		P p = que.front();

		que.pop();

		if (p.first == gx&&p.second == gy)

			break;

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

		{

			int nx = p.first + dx[i];

			int ny = p.second + dy[i];

			if (nx >= 0 && nx < N&&ny >= 0 && ny < M&&a[nx][ny] != 'X'&&d[nx][ny] == INF)

			{

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

				d[nx][ny] = d[p.first][p.second] + 1;

			}

		}



	}

	return d[gx][gy];

}

int main(void)

{

	while (cin >> N >> M)

	{

		int n, sum = 0;

		cin >> n;

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

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

				cin >> a[i][j];

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

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

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

				{

					sx = j;

					sy = k;

				}

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

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

				if (a[j][k] == '1')

				{

					gx = j;

					gy = k;

				}

		sum += bfs();

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

		{

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

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

				{

					if (a[j][k] == (char)(i+49))

					{

						sx = j;

						sy = k;

					}

					if (a[j][k] == (char)(i+50))

					{

						gx = j;

						gy = k;

					}

				}

			sum += bfs();



		}

		cout << sum << endl;

	}

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

#include<string.h>

#include<queue>

using namespace std;

const int maxn=1005;

int n,m,k,dx[]={-1,1,0,0},dy[]={0,0,1,-1},vis[maxn][maxn];

char map[maxn][maxn];

struct maze

{

    maze(int xx=0,int yy=0,int tt=0):x(xx),y(yy),time(tt){}

	int x,y,time;

};

maze bfs(int bx,int by,char ch)

{

	memset(vis,0,sizeof(vis));

	queue<maze> q;

	maze st(bx,by,0);

	q.push(st);vis[bx][by]=1;

	while(!q.empty())

	{

		st=q.front();q.pop();

		if(map[st.x][st.y]==ch)

		{

			return st;

		}

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

		{

			int tx=st.x+dx[i],ty=st.y+dy[i];

			if(tx<0||tx>=n||ty<0||ty>=m||map[tx][ty]=='X')//越界和?

			{

				continue;

			}

			maze tp(tx,ty,st.time+1);

			if(!vis[tx][ty])

			{

				vis[tx][ty]=1;

				q.push(tp);

			}

		}

	}

}

int main()

{



	while(~scanf("%d%d%d",&n,&m,&k))

	{

		int bx,by;

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

		{

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

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

			{

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

				{

					bx=i;by=j;

					

					map[i][j]='0'; //第0个起点

				}

			}

		}

		int ans=0;

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

		{

			maze tp=bfs(bx,by,map[bx][by]+1);

			ans+=tp.time;

			bx=tp.x;by=tp.y;

		}

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

	}

	return 0;

}

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

#include<algorithm>

#include<queue>

const int INF = 100000000;

using namespace std;

typedef pair<int, int> P;

char a[1005][1005];

int N, M;

int sx, sy;

int gx, gy;

int d[1005][1005];

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

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

int bfs()

{

	queue<P> que;

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

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

			d[i][j] = INF;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		P p = que.front();

		que.pop();

		if (p.first == gx&&p.second == gy)

			break;

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

		{

			int nx = p.first + dx[i];

			int ny = p.second + dy[i];

			if (nx >= 0 && nx < N&&ny >= 0 && ny < M&&a[nx][ny] != 'X'&&d[nx][ny] == INF)

			{

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

				d[nx][ny] = d[p.first][p.second] + 1;

			}

		}



	}

	return d[gx][gy];

}

int main(void)

{

	while (cin >> N >> M)

	{

		int n, sum = 0;

		cin >> n;

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

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

				cin >> a[i][j];

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

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

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

				{

					sx = j;

					sy = k;

				}

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

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

				if (a[j][k] == '1')

				{

					gx = j;

					gy = k;

				}

		sum += bfs();

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

		{

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

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

				{

					if (a[j][k] == (char)(i+49))

					{

						sx = j;

						sy = k;

					}

					if (a[j][k] == (char)(i+50))

					{

						gx = j;

						gy = k;

					}

				}

			sum += bfs();



		}

		cout << sum << endl;

	}

}
// 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: 12.56635467526184x):
#include<iostream>

#include<iomanip>

#include<math.h>

#include<vector>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<stack>

#include<string>

#include<time.h>

#define INF 1000000000ll

#define MOD 1000000007ll

#define EPS 1e-10

#define REP(i,m) for(long long i=0; i<m; i++)

#define FOR(i,n,m) for(long long i=n; i<m; i++)

#define DUMP(a) for(long long dump=0; dump<(ll)a.size(); dump++) { cout<<a[dump]; if(dump!=n-1) cout<<" "; else cout<<endl; }

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

#define pb push_back

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

typedef long double ld;



/*

 貪欲

 ?決定問題 必ず解に含まれる(含むように変換できる)ものから決めていく みんプロ本選B

 ?最適化問題 任意の解から評価を落とさず解に含められるようなものから決めていく 区間スケジューリングとか

 ?

 */



/*

 DP

 ?DPはある程度決め打ちをするべき(解を帰納的に構成できないか？)

 */



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);

	ll h,w,n;

	cin>>h>>w>>n;

	vector<vector<char>> m(h,vector<char>(w));

	REP(i,h) REP(j,w) cin>>m[i][j];

	ll ret=0;

	REP(i,n) {

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

		queue<P> q;

		REP(j,h) REP(k,w) {

			if(i==0) {

				if(m[j][k]=='S') {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			} else {

				if(m[j][k]=='0'+i) {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			}

		}

		while(!q.empty()) {

			P p=q.front();

			q.pop();

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

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

			REP(j,4) {

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

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

				if(nx>=0&&nx<h&&ny>=0&&ny<w&&m[nx][ny]!='X'&&dir[nx][ny]==INF) {

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

					dir[nx][ny]=dir[p.first][p.second]+1;

				}

			}

		}

		REP(j,h) REP(k,w) {

			if(m[j][k]=='1'+i) ret+=dir[j][k];

		}

	}

	cout<<ret<<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.969560519223227x):
#include<iostream>

#include<iomanip>

#include<math.h>

#include<vector>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<stack>

#include<string>

#include<time.h>

#define INF 1000000000ll

#define MOD 1000000007ll

#define EPS 1e-10

#define REP(i,m) for(long long i=0; i<m; i++)

#define FOR(i,n,m) for(long long i=n; i<m; i++)

#define DUMP(a) for(long long dump=0; dump<(ll)a.size(); dump++) { cout<<a[dump]; if(dump!=n-1) cout<<" "; else cout<<endl; }

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

#define pb push_back

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

typedef long double ld;



/*

 貪欲

 ?決定問題 必ず解に含まれる(含むように変換できる)ものから決めていく みんプロ本選B

 ?最適化問題 任意の解から評価を落とさず解に含められるようなものから決めていく 区間スケジューリングとか

 ?

 */



/*

 DP

 ?DPはある程度決め打ちをするべき(解を帰納的に構成できないか？)

 */



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);

	ll h,w,n;

	cin>>h>>w>>n;

	vector<vector<char>> m(h,vector<char>(w));

	REP(i,h) REP(j,w) cin>>m[i][j];

	ll ret=0;

	REP(i,n) {

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

		queue<P> q;

		REP(j,h) REP(k,w) {

			if(i==0) {

				if(m[j][k]=='S') {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			} else {

				if(m[j][k]=='0'+i) {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			}

		}

		while(!q.empty()) {

			P p=q.front();

			q.pop();

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

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

			REP(j,4) {

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

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

				if(nx>=0&&nx<h&&ny>=0&&ny<w&&m[nx][ny]!='X'&&dir[nx][ny]==INF) {

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

					dir[nx][ny]=dir[p.first][p.second]+1;

				}

			}

		}

		REP(j,h) REP(k,w) {

			if(m[j][k]=='1'+i) ret+=dir[j][k];

		}

	}

	cout<<ret<<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.903846227274983x):
#include<iostream>

#include<iomanip>

#include<math.h>

#include<vector>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<stack>

#include<string>

#include<time.h>

#define INF 1000000000ll

#define MOD 1000000007ll

#define EPS 1e-10

#define REP(i,m) for(long long i=0; i<m; i++)

#define FOR(i,n,m) for(long long i=n; i<m; i++)

#define DUMP(a) for(long long dump=0; dump<(ll)a.size(); dump++) { cout<<a[dump]; if(dump!=n-1) cout<<" "; else cout<<endl; }

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

#define pb push_back

using namespace std;

typedef long long ll;

typedef pair<ll, ll> P;

typedef long double ld;



/*

 貪欲

 ?決定問題 必ず解に含まれる(含むように変換できる)ものから決めていく みんプロ本選B

 ?最適化問題 任意の解から評価を落とさず解に含められるようなものから決めていく 区間スケジューリングとか

 ?

 */



/*

 DP

 ?DPはある程度決め打ちをするべき(解を帰納的に構成できないか？)

 */



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);

	ll h,w,n;

	cin>>h>>w>>n;

	vector<vector<char>> m(h,vector<char>(w));

	REP(i,h) REP(j,w) cin>>m[i][j];

	ll ret=0;

	REP(i,n) {

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

		queue<P> q;

		REP(j,h) REP(k,w) {

			if(i==0) {

				if(m[j][k]=='S') {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			} else {

				if(m[j][k]=='0'+i) {

					dir[j][k]=0;

					q.push(P(j,k));

				}

			}

		}

		while(!q.empty()) {

			P p=q.front();

			q.pop();

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

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

			REP(j,4) {

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

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

				if(nx>=0&&nx<h&&ny>=0&&ny<w&&m[nx][ny]!='X'&&dir[nx][ny]==INF) {

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

					dir[nx][ny]=dir[p.first][p.second]+1;

				}

			}

		}

		REP(j,h) REP(k,w) {

			if(m[j][k]=='1'+i) ret+=dir[j][k];

		}

	}

	cout<<ret<<endl;

}