// Original C++ solution (slower):
//??-2015-11-1

# include <cstdio>

# include <string>

# include <cstring>

# include <algorithm>

# include <iostream>

# include <queue>



using namespace std;



int direction[4][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, {0,1} };                  //四个方向，上下左右

struct node

{

	int w, h;

	int step;

};

struct node2

{

	int h, w, value;

};

int H, W, N;

string s[1005];

int vis[1005][1005];

int cmp(node2 a, node2 b)

{

	if (a.value < b.value)

		return 1;

	else

		return 0;

}

int DFS(int begin_h, int begin_w, int end_h, int end_w)

{

	int i, j,w = 0;

	queue<node>Q;

	node temp;

	temp.h = begin_h;

	temp.w = begin_w;

	temp.step = 0;

	Q.push(temp);

	vis[begin_h][begin_w] = 1;

	while (!Q.empty())                     //?列不空的?

	{

		node temp1 = Q.front();

		Q.pop();

		//printf("%d\n", w++);

		if (temp1.h == end_h&&temp1.w == end_w)

		{

			return temp1.step;

		}

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

		{

			if (temp1.h + direction[i][0] >= 0 && temp1.h + direction[i][0] < H&&temp1.w + direction[i][1] >= 0 && temp1.w + direction[i][1] < W&&!vis[temp1.h + direction[i][0]][temp1.w + direction[i][1]] && s[temp1.h + direction[i][0]][temp1.w + direction[i][1]] == '.')

			{

				node temp2;

				temp2.h = temp1.h + direction[i][0];

				temp2.w = temp1.w + direction[i][1];

				temp2.step = temp1.step + 1;

				vis[temp1.h + direction[i][0]][temp1.w + direction[i][1]] = 1;

				Q.push(temp2);

			}

		}

	}

}

int main(void)

{

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

	int i, j,k = 1;

	int all_step = 0;

	int s_h, s_w,e_h,e_w;

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

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

	node2 node1[20];

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

	{

		cin >> s[i];

		for (j = 0; j < s[i].length(); j++)

		{

			if (s[i][j] >= '0'&&s[i][j] <= '9')

			{

				node1[k].h = i;

				node1[k].w = j;

				node1[k].value = s[i][j] - '0';                //保留?

				k++;

				s[i][j] = '.';                                  //?了BFS的?候?理一致

			}

			else if (s[i][j] == 'S')                            //?始?点

			{

				s_h = i;

				s_w = j;

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

			}

		}

	}

		sort(node1+1, node1 + N+1, cmp);                             //先排好序

		node1[0].h = s_h;                                            //?了使下面循?一?

		node1[0].w = s_w;

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

		{

			e_h = node1[i+1].h;                                      //?点的坐?

			e_w = node1[i+1].w;

			s_h = node1[i].h;

			s_w = node1[i].w;

			//printf("step=%d\n", DFS(s_h, s_w, e_h, e_w));

			all_step += DFS(s_h, s_w, e_h, e_w);                       //原来的?点??起始点

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

		}

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

	

	return 0;

}

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

#include <queue>

using namespace std;

int w, h, n;

char map[1024][1024];

int d[1024][1024];

const int direction[4][2] = {

	{ -1, 0 },

	{ 1, 0 },

	{ 0, -1 },

	{ 0, 1 },

};



int factory[16][2];

typedef pair<int, int> P;



int bfs(const int& sx, const int& sy, const int& gx, const int& gy)

{

	//memset(d, -1, sizeof(d));

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

	{

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

		{

			d[j][i] = -1;

		}

	}

	queue<P> que;

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

	d[sx][sy] = 0;

	while (que.size())

	{

		const 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 + direction[i][0];

			int ny = p.second + direction[i][1];

			// 是否可以移?，并且?点没有???

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

			{

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

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

			}

		}

	}



	return d[gx][gy];

}



///////////////////////////SubMain//////////////////////////////////

int main(int argc, char *argv[])

{



	cin >> h >> w >> n;

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

	{

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

		{

			cin >> map[j][i];

		}

	}



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

	{

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

		{

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

			{

				factory[0][0] = j;

				factory[0][1] = i;

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

			}

			else if (isdigit(map[j][i]))

			{

				int index = map[j][i] - '0';

				factory[index][0] = j;

				factory[index][1] = i;

			}

		}

	}



	int step = 0;

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

	{

		

		step += bfs(factory[i][0], factory[i][1], factory[i + 1][0], factory[i + 1][1]);

	}



	cout << step << endl;



	return 0;

}

// Fastest known solution for this problem: