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

#include<algorithm>

#include<math.h>

#include<string.h>

#include<queue>

#include<stdio.h>

using namespace std;



typedef struct{

	int x,y;

}p;

char a[1005][1005];

p acm[11];

p s,g;

int b[1005][1005];

int H,W,N;

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

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

int bfs(p s,p g)

{

	queue<p> q;

	p n;

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

	q.push(s);

	b[s.x][s.y]=0;

	while(!q.empty())

	{

		p h;

		h=q.front();

		q.pop();

		if(h.x==g.x&&h.y==g.y)

		{

			break;

		}

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

		{

			n.x=h.x+dx[i];

			n.y=h.y+dy[i];

			if(n.x>=0&&n.x<H&&n.y>=0&&n.y<W&&a[n.x][n.y]!='X'&&b[n.x][n.y]==-1)

			{

				q.push(n);

				b[n.x][n.y]=b[h.x][h.y]+1;

			}

		}

	}

	return b[g.x][g.y];

}

int main()

{

	int i,j,t,step=0;

	scanf("%d%d%d",&H,&W,&N);

	for(i=0;i<H;i++)

	{

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

	}

	for(i=0;i<H;i++)

	for(j=0;j<W;j++)

	{

		if(a[i][j]>='1'&&a[i][j]<='9')

		{

			t=a[i][j]-'0';

		    acm[t].x=i;

		    acm[t].y=j;

		}

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

		{

			s.x=i;

			s.y=j;

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

		}

	}

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

		{

			g.x=acm[i].x;

			g.y=acm[i].y;

			step+=bfs(s,g);

			s.x=g.x;

			s.y=g.y;

			a[g.x][g.y]='.';

		}

	

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

	return 0;

 } 


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

#include<cstdio>

#include<queue>

#include<cstring>

#include<vector>

#include<set>

using namespace std;

typedef long long ll;

int H,W,N;

char mm[1005][1005];

bool v[1005][1005];

int xx,yy;

struct node{

    int x,y,step;

};

queue<node> que;

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

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

bool check(int x,int  y){

    if(1<=x&&x<=H&&1<=y&&y<=W&&!v[x][y]&&mm[x][y]!='X')return true;

    else return false;

}

int bfs(int g){

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

    node t;

    t.x=xx;

    t.y=yy;

    t.step=0;

    v[xx][yy]=1;

    que.push(t);

    while(!que.empty()){

        t=que.front();

        que.pop();

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

            int nx=t.x+dx[i];

            int ny=t.y+dy[i];

            if(check(nx,ny)){

                if(mm[nx][ny]==g+'0'){

                    xx=nx;

                    yy=ny;

                    return t.step+1;

                }

                node tt;

                tt.x=nx;

                tt.y=ny;

                tt.step=t.step+1;

                v[nx][ny]=1;

                que.push(tt);

            }

        }

    }

}

int main(){

    while(~scanf("%d%d%d",&H,&W,&N)){

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

            scanf("%s",mm[i]+1);

        }

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

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

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

                    xx=i;

                    yy=j;

                }

            }

        }

        int ans=0;

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

            memset(v,0,sizeof(v));

            ans+=bfs(i);

        }

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

    }

    return 0; 

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

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<queue>

#include<stack>

#include<set>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int MAX_N=100000;

const int INF = 0x3f3f3f3f;

int n,m,k;

char map[1010][1010];

bool vis[1010][1010];



struct p{

	int x;

	int y;

	int step;

};

int ans=0;



bool yesorno(p x){

	if(x.x<1||x.x>m||x.y<1||x.y>n||map[x.y][x.x]=='X'||vis[x.y][x.x]==1)

		return 0;

	return 1;

}



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

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

void bfs(p st,int ww){

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

	if(ww==k)

		return;

	int temp=0;

	queue<p> q;

	q.push(st);

//	cout<<st.step<<" "<<ww<<" "<<k<<endl;

	while(!q.empty()){

		

		p ne=q.front();

		q.pop();

		if(map[ne.y][ne.x]==(char)'0'+ww+1){

			ans=ne.step;

			bfs(ne,ww+1);

			return;

		}

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

			p tem=ne;

			tem.x=tem.x+sx[i];

			tem.y=tem.y+sy[i];

			tem.step++;

			if(yesorno(tem)){

				q.push(tem);

				vis[tem.y][tem.x]=1;

			}

				

		}

	}

}

int main(){

	ios::sync_with_stdio(false);

	while(cin>>n>>m>>k){

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

		p st;

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

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

				cin>>map[i][j];

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

					st.x=j;

					st.y=i;

					st.step=0;

				}

			}

		}

		bfs(st,0);

		cout<<ans<<endl;

	}





	return 0;

}






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

#include<cstdio>

#include<queue>

#include<cstring>

#include<vector>

#include<set>

using namespace std;

typedef long long ll;

int H,W,N;

char mm[1005][1005];

bool v[1005][1005];

int xx,yy;

struct node{

    int x,y,step;

};

queue<node> que;

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

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

bool check(int x,int  y){

    if(1<=x&&x<=H&&1<=y&&y<=W&&!v[x][y]&&mm[x][y]!='X')return true;

    else return false;

}

int bfs(int g){

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

    node t;

    t.x=xx;

    t.y=yy;

    t.step=0;

    v[xx][yy]=1;

    que.push(t);

    while(!que.empty()){

        t=que.front();

        que.pop();

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

            int nx=t.x+dx[i];

            int ny=t.y+dy[i];

            if(check(nx,ny)){

                if(mm[nx][ny]==g+'0'){

                    xx=nx;

                    yy=ny;

                    return t.step+1;

                }

                node tt;

                tt.x=nx;

                tt.y=ny;

                tt.step=t.step+1;

                v[nx][ny]=1;

                que.push(tt);

            }

        }

    }

}

int main(){

    while(~scanf("%d%d%d",&H,&W,&N)){

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

            scanf("%s",mm[i]+1);

        }

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

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

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

                    xx=i;

                    yy=j;

                }

            }

        }

        int ans=0;

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

            memset(v,0,sizeof(v));

            ans+=bfs(i);

        }

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

    }

    return 0; 

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

#include <string.h>

#include <iostream>

#include <algorithm>

#include <math.h>

#include <vector>

#include <queue>

using namespace std;

int n,m,p;

int sx,sy;

char s[1505][1505];

struct node{

	int x,y,step;

	node(int sx,int sy,int step)

	{

		this->x=sx;this->y=sy;this->step=step;

	}

};

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

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

int vis[1505][1500];

node bfs(node u,int pos)

{

	queue<node> q;

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

	q.push(u);

	

	while(!q.empty())

	{

		node v=q.front();q.pop();

		if(s[v.x][v.y]==pos+'0') return v;

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

		{

			int x=v.x+dx[i];

			int y=v.y+dy[i];

			if(x>=1&&x<=n&&y>=1&&y<=m&&s[x][y]!='X'&&vis[x][y]==0)

			{

				vis[x][y]=1;

				node now=node(x,y,v.step+1);

				q.push(now);

			}

		}

	}

}

int main()

{

	while(cin>>n>>m>>p)

	{

		int ans=0;

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

		{

			cin>>s[i]+1;

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

			{

				if(s[i][j]=='S') sx=i,sy=j;

			}

		}

		node u=node(sx,sy,0);	

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

		{		

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

			vis[u.x][u.y]=1;

			u=bfs(u,i);

			ans+=u.step;

			u.step=0;

		}

		cout<<ans<<endl;

	}

	return 0;

}


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

#include<cstdio>

#include<queue>

#include<cstring>

#include<vector>

#include<set>

using namespace std;

typedef long long ll;

int H,W,N;

char mm[1005][1005];

bool v[1005][1005];

int xx,yy;

struct node{

    int x,y,step;

};

queue<node> que;

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

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

bool check(int x,int  y){

    if(1<=x&&x<=H&&1<=y&&y<=W&&!v[x][y]&&mm[x][y]!='X')return true;

    else return false;

}

int bfs(int g){

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

    node t;

    t.x=xx;

    t.y=yy;

    t.step=0;

    v[xx][yy]=1;

    que.push(t);

    while(!que.empty()){

        t=que.front();

        que.pop();

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

            int nx=t.x+dx[i];

            int ny=t.y+dy[i];

            if(check(nx,ny)){

                if(mm[nx][ny]==g+'0'){

                    xx=nx;

                    yy=ny;

                    return t.step+1;

                }

                node tt;

                tt.x=nx;

                tt.y=ny;

                tt.step=t.step+1;

                v[nx][ny]=1;

                que.push(tt);

            }

        }

    }

}

int main(){

    while(~scanf("%d%d%d",&H,&W,&N)){

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

            scanf("%s",mm[i]+1);

        }

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

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

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

                    xx=i;

                    yy=j;

                }

            }

        }

        int ans=0;

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

            memset(v,0,sizeof(v));

            ans+=bfs(i);

        }

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

    }

    return 0; 

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

#include<cstdio>

#include<queue>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

typedef pair<int,int>P;

const int Max_n=1100;



int n,m,d;

struct Node{

    int x,y,d;

    Node(int xx,int yy,int dd):x(xx),y(yy),d(dd){}

};

char s[Max_n][Max_n];

bool vis[Max_n][Max_n];

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

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



Node bfs(int x1,int y1,int k){

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

    queue<Node>que;

    que.push(Node(x1,y1,0));

    vis[x1][y1]=1;

    while(!que.empty()){

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

        int x=node.x,y=node.y;

        if(k==s[x][y]-'0')return node;

        int d=node.d;

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

            int X=x+dx[i],Y=y+dy[i];

            if(!vis[X][Y]&&(s[X][Y]=='S'||s[X][Y]=='.'||(s[X][Y]>='1'&&s[X][Y]<='9'))){

                vis[X][Y]=1;

                que.push(Node(X,Y,d+1));

            }

        }

    }

}



int main()

{

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

        memset(s,0,sizeof(s));

        for(int i=1;i<=n;i++)scanf("%s",s[i]+1);

        int x,y;

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

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

            if(s[i][j]=='S'){x=i;y=j;}

        }

        int sum=0;

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

            Node node=bfs(x,y,i);

            sum+=node.d;

            x=node.x,y=node.y;

        }

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

    }

    return 0;

}






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

#include<cstdio>

#include<queue>

#include<cstring>

#include<vector>

#include<set>

using namespace std;

typedef long long ll;

int H,W,N;

char mm[1005][1005];

bool v[1005][1005];

int xx,yy;

struct node{

    int x,y,step;

};

queue<node> que;

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

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

bool check(int x,int  y){

    if(1<=x&&x<=H&&1<=y&&y<=W&&!v[x][y]&&mm[x][y]!='X')return true;

    else return false;

}

int bfs(int g){

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

    node t;

    t.x=xx;

    t.y=yy;

    t.step=0;

    v[xx][yy]=1;

    que.push(t);

    while(!que.empty()){

        t=que.front();

        que.pop();

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

            int nx=t.x+dx[i];

            int ny=t.y+dy[i];

            if(check(nx,ny)){

                if(mm[nx][ny]==g+'0'){

                    xx=nx;

                    yy=ny;

                    return t.step+1;

                }

                node tt;

                tt.x=nx;

                tt.y=ny;

                tt.step=t.step+1;

                v[nx][ny]=1;

                que.push(tt);

            }

        }

    }

}

int main(){

    while(~scanf("%d%d%d",&H,&W,&N)){

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

            scanf("%s",mm[i]+1);

        }

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

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

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

                    xx=i;

                    yy=j;

                }

            }

        }

        int ans=0;

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

            memset(v,0,sizeof(v));

            ans+=bfs(i);

        }

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

    }

    return 0; 

}
// 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: 2.07874993886722x):
#include<stdio.h>

#include<vector>

#include<queue>

#include<string.h>

#include<iostream>

#include<algorithm>

#define INF 1000000000

#define MAXN 100005

using namespace std;

int mmin=11;

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

int a[1005][1005];int m,n,k,sx,sy;

struct node{

    int x,y,cost;

};

int bfs(int x,int y,int s)

{

    queue<node>q;

    bool vis[1005][1005]={0};

    node now={x,y,0};

    q.push(now);

    while(!q.empty())

    {

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

        if(a[now.x][now.y]==s)break;

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

        {

            int xx=now.x+step[i][0],yy=now.y+step[i][1];

            if(!vis[xx][yy]&&a[xx][yy]!=-1){

                vis[xx][yy]=1;

                node temp={xx,yy,now.cost+1};

                q.push(temp);



            }

        }

    }

    //cout<<now.cost<<endl;

    sx=now.x;sy=now.y;

    return now.cost;

}

int main()

{

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

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

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

        string x;cin>>x;

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

        {

            char c=x[j-1];

            if(c=='S'){a[i][j]=0;sx=i;sy=j;}

            else if(c=='X')a[i][j]=-1;

            else if(c=='.')a[i][j]=0;

            else a[i][j]=c-'0';

        }

    }

    int sum=0;

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

    {

        sum+=bfs(sx,sy,i);

    }

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

}
// Slower C++ solution:


#include <iostream>

#include <cstdio>

#include <cstring>

#include <queue>



using namespace std;

const int maxn = 1e3 + 5;

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

int mp[maxn][maxn];

//bool vis[maxn][maxn];

int d[maxn][maxn];

struct point{

    int x,y;

};

int h,w,n;

 int dis = 0;

void bfs(point &p,int cnt)

{

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

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

    queue<point> q;

    q.push(p);

    while (!q.empty()) {

        point t = q.front();q.pop();

        //vis[t.x][t.y] = true;

        if(mp[t.x][t.y] == cnt + 1) {dis += d[t.x][t.y];p.x = t.x,p.y = t.y;return ;}

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

            int tx = t.x + dir[i][0];

            int ty = t.y + dir[i][1];

            if (tx >= 0 && tx < h && ty >= 0 && ty < w && !d[tx][ty] && mp[tx][ty] != -1) {

                q.push({tx,ty});

                d[tx][ty] = 1 + d[t.x][t.y];

            }

        }

    }

}

int main()

{

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

        getchar();

        char ch;

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

       // int sx,sy;

        point s;

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

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

                scanf("%c",&ch);

                if(ch == 'S') {s.x = i,s.y = j;mp[i][j] = 0;}

                else if(ch == '.') {mp[i][j] = 0;}

                else if(isdigit(ch)) {mp[i][j] = ch - '0';}

            }

            getchar();

        }

       

        dis = 0;

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

            bfs(s,i);

        }

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

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.5216863461582537x):
#include<stdio.h>

#include<vector>

#include<queue>

#include<string.h>

#include<iostream>

#include<algorithm>

#define INF 1000000000

#define MAXN 100005

using namespace std;

int mmin=11;

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

int a[1005][1005];int m,n,k,sx,sy;

struct node{

    int x,y,cost;

};

int bfs(int x,int y,int s)

{

    queue<node>q;

    bool vis[1005][1005]={0};

    node now={x,y,0};

    q.push(now);

    while(!q.empty())

    {

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

        if(a[now.x][now.y]==s)break;

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

        {

            int xx=now.x+step[i][0],yy=now.y+step[i][1];

            if(!vis[xx][yy]&&a[xx][yy]!=-1){

                vis[xx][yy]=1;

                node temp={xx,yy,now.cost+1};

                q.push(temp);



            }

        }

    }

    //cout<<now.cost<<endl;

    sx=now.x;sy=now.y;

    return now.cost;

}

int main()

{

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

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

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

        string x;cin>>x;

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

        {

            char c=x[j-1];

            if(c=='S'){a[i][j]=0;sx=i;sy=j;}

            else if(c=='X')a[i][j]=-1;

            else if(c=='.')a[i][j]=0;

            else a[i][j]=c-'0';

        }

    }

    int sum=0;

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

    {

        sum+=bfs(sx,sy,i);

    }

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

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

#include <string.h>

#include <iostream>

#include <algorithm>

#include <math.h>

#include <vector>

#include <queue>

using namespace std;

int n,m,p;

int sx,sy;

char s[1505][1505];

struct node{

	int x,y,step;

	node(int sx,int sy,int step)

	{

		this->x=sx;this->y=sy;this->step=step;

	}

};

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

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

int vis[1505][1500];

node bfs(node u,int pos)

{

	queue<node> q;

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

	q.push(u);

	

	while(!q.empty())

	{

		node v=q.front();q.pop();

		if(s[v.x][v.y]==pos+'0') return v;

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

		{

			int x=v.x+dx[i];

			int y=v.y+dy[i];

			if(x>=1&&x<=n&&y>=1&&y<=m&&s[x][y]!='X'&&vis[x][y]==0)

			{

				vis[x][y]=1;

				node now=node(x,y,v.step+1);

				q.push(now);

			}

		}

	}

}

int main()

{

	while(cin>>n>>m>>p)

	{

		int ans=0;

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

		{

			cin>>s[i]+1;

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

			{

				if(s[i][j]=='S') sx=i,sy=j;

			}

		}

		node u=node(sx,sy,0);	

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

		{		

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

			vis[u.x][u.y]=1;

			u=bfs(u,i);

			ans+=u.step;

			u.step=0;

		}

		cout<<ans<<endl;

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.6985090098438664x):
#include<stdio.h>

#include<vector>

#include<queue>

#include<string.h>

#include<iostream>

#include<algorithm>

#define INF 1000000000

#define MAXN 100005

using namespace std;

int mmin=11;

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

int a[1005][1005];int m,n,k,sx,sy;

struct node{

    int x,y,cost;

};

int bfs(int x,int y,int s)

{

    queue<node>q;

    bool vis[1005][1005]={0};

    node now={x,y,0};

    q.push(now);

    while(!q.empty())

    {

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

        if(a[now.x][now.y]==s)break;

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

        {

            int xx=now.x+step[i][0],yy=now.y+step[i][1];

            if(!vis[xx][yy]&&a[xx][yy]!=-1){

                vis[xx][yy]=1;

                node temp={xx,yy,now.cost+1};

                q.push(temp);



            }

        }

    }

    //cout<<now.cost<<endl;

    sx=now.x;sy=now.y;

    return now.cost;

}

int main()

{

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

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

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

        string x;cin>>x;

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

        {

            char c=x[j-1];

            if(c=='S'){a[i][j]=0;sx=i;sy=j;}

            else if(c=='X')a[i][j]=-1;

            else if(c=='.')a[i][j]=0;

            else a[i][j]=c-'0';

        }

    }

    int sum=0;

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

    {

        sum+=bfs(sx,sy,i);

    }

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

}
// 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: 3.1423393170166314x):
#include<queue>

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;



#define MAXN 1000

struct node{

    int x,y,st;

    bool operator == (node B) const{

        return x==B.x&&y==B.y;

    }

};

int H,W,N;

char Map[MAXN+5][MAXN+5];

bool vis[MAXN+5][MAXN+5];



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

int bfs(node S,node T){

    queue<node> Q;

    Q.push(S);

    memset(vis,0,sizeof vis);

    while(!Q.empty()){

        node u=Q.front();Q.pop();

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

            node tmp=u;

            tmp.x+=dir[i][0],tmp.y+=dir[i][1],tmp.st++;

            if(tmp.x<1||tmp.x>H||tmp.y<1||tmp.y>W||vis[tmp.x][tmp.y]||Map[tmp.x][tmp.y]=='X')

                continue;

            if(tmp==T)

                return tmp.st;

            vis[tmp.x][tmp.y]=1;

            Q.push(tmp);

        }

    }

    return -1;

}



pair<int,int> pos[10];



int main(){

    scanf("%d%d%d",&H,&W,&N);

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

        scanf("%s",Map[i]+1);

    node S;

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

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

            if(Map[i][j]!='.'&&Map[i][j]!='X'&&Map[i][j]!='S')

                pos[Map[i][j]-'1'+1]=make_pair(i,j);

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

                S.x=i,S.y=j,S.st=0;

        }

    int Ans=0;

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

        Ans+=bfs(S,(node){pos[i].first,pos[i].second,0});

        S=(node){pos[i].first,pos[i].second,0};

    }

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

}