// Original C++ solution (slower):
#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  

{  

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

                }  

            }  

        }  

        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;  

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include <queue>

using namespace std;

const int INF = 100000000;

typedef pair<int,int> Point;

Point AllPoint[1000];

int W,H;

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

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

char map[1000][1000];

int deep[1000][1000];

int N;

void BFS(Point Start,Point Over){

    queue<Point> que;

    int FirstDeep = deep[Start.first][Start.second];

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

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

            deep[i][j] = INF;

        }

    }

    que.push(Start);

    deep[Start.first][Start.second] = FirstDeep;

    while (que.size()){

        Point p = que.front();

        que.pop();

        if (p.first== Over.first&&p.second == Over.second)

            break;

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

            int ix = p.first+x[i];

            int iy = p.second+y[i];

            if (ix>=0&&ix<=H

                &&iy>=0&&iy<=W

                &&deep[ix][iy] == INF

                &&map[ix][iy]!='X'){

                que.push(Point(ix,iy));

                deep[ix][iy] = deep[p.first][p.second]+1;

            }

        }

    }

}







int main(){

    cin >> H >> W;

    cin >> N;

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

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

            cin >> map[i][j];

            if ((int)map[i][j]-48>=1&&(int)map[i][j]-48<=N){

                AllPoint[(int)map[i][j]-48].first = i;

                AllPoint[(int)map[i][j]-48].second = j;



            }

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

                AllPoint[0].first = i;

                AllPoint[0].second = j;

            }

        }

    }

    deep[AllPoint[0].first][AllPoint[0].second] = 0;

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

        BFS(AllPoint[i],AllPoint[i+1]);

    }

    cout << deep[AllPoint[N].first][AllPoint[N].second]<<endl;



    return 0;

}

//#....

//S.##.

//###G.

//#####

//#####



//#S######.#

//......#..#

//.#.##.##.#

//.#........

//##.##.####

//....#....#

//.#######.#

//....#.....

//.####.###.

//....#...G#






// Fastest known solution for this problem: