#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <queue>

using namespace std;

struct shark {
	int x, y, size;
};

int map[22][22];
int check[22][22];

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

void init_check(int n)
{
	for (int j = 0; j < n; j++)
	{
		for (int i = 0; i < n; i++)
		{
			check[j][i] = 0;
		}
	}
}

void shark_grow(int &eat_cnt, shark &baby)
{
	if (eat_cnt == baby.size)
	{//만약 먹은량이 상어크기와 같다면
		baby.size++; // 상어 크기 키우고
		eat_cnt = 0; // 먹은량 초기화
	}
}

int main()
{
	int N;
	scanf("%d ", &N);
	shark baby;
	for (int j = 0; j < N; j++)
	{
		for (int i = 0; i < N; i++)
		{
			scanf("%d", &map[j][i]);
			if (map[j][i] == 9)
			{
				baby.x = i;
				baby.y = j;
				baby.size = 2;
				map[j][i] = 0;
			}
		}
	}

	int answer = 0;
	bool flag = false;
	int eat_count = 0;
	int timer = 0;
	while (1)
	{
		//더 이상 먹을 고기 없는 경우 빠져나간다.
		if (flag) break;

		//check 맵 매 초마다 초기화
		init_check(N);

		//상어 현재 위치 check
		queue<pair<int, int>> q;

		int cx = baby.x;
		int cy = baby.y;
		
		check[cy][cx] = 1;
		q.push(make_pair(cx, cy));
		bool eat = false;
		
		int distance = 1000;
		int min_x = 1000;
		int min_y = 1000;

		while (!q.empty())
		{
			cx = q.front().first;
			cy = q.front().second;
			q.pop();
			for (int i = 0; i < 4; i++)
			{ //상어 다음 위치를 간다.
				int nx = cx + dx[i];
				int ny = cy + dy[i];
				if (0 <= nx && nx < N && 0 <= ny && ny < N&&check[ny][nx] == 0 && map[ny][nx] <= baby.size)
				{//맵 영역 안이고, 간 적이 없고, 맵 물고기 크기가 상어 이하라면 간다.
					//일단 방문한다.
					check[ny][nx] = check[cy][cx] + 1;
					q.push(make_pair(nx, ny));
					if (0 < map[ny][nx] && map[ny][nx] < baby.size)
					{//먹을 수 있는 물고기가 존재한다면
						eat = true; // 먹는다고 표시 하고
						if (check[ny][nx] < distance)
						{//만약 지금 방문한 위치가 가장 가깝다면
							min_x = nx; // 최소 위치 초기화
							min_y = ny;
							distance = check[ny][nx];
						}
						else if (check[ny][nx] == distance)
						{//만약 지금 방문한 거리가 가장 가까운 거리와 같다면
							int temp = min_x;
							if (ny < min_y)
							{ // 가장 위의 물고기를 먹고
								min_x = nx;
								min_y = ny;
								if (nx < temp)
								{ // 그중에서도 왼쪽 물고길 먹는다.
									min_x = nx;
									min_y = ny;
								}
							}
						}
					}					
				}
			}
		}
		if (eat)
		{//먹은 고기가 있다면
			eat_count++; // 먹는다.
			baby.x = min_x; // 상어 위치 초기화
			baby.y = min_y;
			map[min_y][min_x] = 0; //먹힌 물고기 지우기
			timer += check[min_y][min_x] - 1; // 먹는데 걸린 시간 더하기

			//상어를 조건에 맞게 키운다.
			shark_grow(eat_count, baby);
		}
		else flag = true; //맵에 먹을 고기 없으면 끝낸다.
	}
	printf("%d\n", timer);
  
	//std::system("pause");
	return 0;
}

#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>

using namespace std;

int map[21][21]; // 주사위 맵
vector<int> order; // 명령어 저장용

int dx[] = { 0,1,-1,0,0 }; // 주사위 굴리기 방향
int dy[] = { 0,0,0,-1,1 };

int dice[] = { 0,0,0,0,0,0 }; // 주사위 값

void rotate_dice(int dir)
{
	int t_dice[] = { 0,0,0,0,0,0 };
	if (dir == 1)
	{//오른쪽 회전
		t_dice[0] = dice[0];
		t_dice[1] = dice[5];
		t_dice[2] = dice[1];
		t_dice[3] = dice[2];
		t_dice[4] = dice[4];
		t_dice[5] = dice[3];
	}
	if (dir == 2)
	{//왼쪽 회전
		t_dice[0] = dice[0];
		t_dice[1] = dice[2];
		t_dice[2] = dice[3];
		t_dice[3] = dice[5];
		t_dice[4] = dice[4];
		t_dice[5] = dice[1];
	}
	if (dir == 3)
	{//위 회전
		t_dice[0] = dice[2];
		t_dice[1] = dice[1];
		t_dice[2] = dice[4];
		t_dice[3] = dice[3];
		t_dice[4] = dice[5];
		t_dice[5] = dice[0];
	}
	if (dir == 4)
	{//아래 회전
		t_dice[0] = dice[5];
		t_dice[1] = dice[1];
		t_dice[2] = dice[0];
		t_dice[3] = dice[3];
		t_dice[4] = dice[2];
		t_dice[5] = dice[4];
	}
	for (int i = 0; i < 6; i++)
	{ // 계산된 주사위를 원래 주사위로 초기화
		dice[i] = t_dice[i];
	}
}

int main()
{
	int H, W, x, y, k;
	scanf("%d %d %d %d %d", &H, &W, &y, &x, &k);
	
	for (int j = 0; j < H; j++)
	{
		for (int i = 0; i < W; i++)
		{
			scanf("%d", &map[j][i]);
		}
	}

	for (int i = 0; i < k; i++)
	{
		int t;
		scanf("%d", &t);
		order.push_back(t);
	}

	int cx = x; // 현재 위치를 받고
	int cy = y;
	for (int i = 0; i < k; i++)
	{//전체 명령어 동안
		int nx = cx + dx[order[i]]; // 다음 위치를 만든다음
		int ny = cy + dy[order[i]];

		//만약 범위 벗어나지 않는다면
		if (0 <= nx && nx < W && 0 <= ny && ny < H)
		{
			//주사위 회전시키고
			rotate_dice(order[i]);

			//주사위 값 초기화와 맵 값 채우기
			if (map[ny][nx] != 0)
			{//만약 map에 값이 있다면
				dice[5] = map[ny][nx]; // 주사위 값 초기화
				map[ny][nx] = 0; // 맵을 비운다.
			}
			else
			{//만약 map에 값이 없다면(0)
				map[ny][nx] = dice[5]; // 맵 값을 초기화
			}
			printf("%d\n", dice[2]); // 주사위 위쪽 출력
			cx = nx; // 다음 위치 초기화
			cy = ny;
		}
	}
	//std::system("pause");
	return 0;
}

#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>

using namespace std;

struct shark
{
	int s, d, z;
};//s: 상어 속도, d: 상어 방향, z: 상어 크기

struct zips
{
	int next, dir; // 다음 위치와 방향 저장용
};

struct position
{
	int nx, ny, dir; // 다음 좌표와 방향 저장용
};

shark sharks[102][102]; // 상어 저장용
shark temp[102][102]; // 상어 이동용

int dx[] = { 0,0,0,1,-1 }; // 각각 상어의 숫자로 매핑된 이동방향
int dy[] = { 0,-1,1,0,0 };

void temp_init(int w, int h)
{ // temp 배열을 0값으로 초기화한다.
	for (int j = 1; j < h + 1; j++)
	{
		for (int i = 1; i < w + 1; i++)
		{
			temp[j][i].s = 0;
			temp[j][i].d = 0;
			temp[j][i].z = 0;
		}
	}
}

void sharks_init(int w, int h)
{
	for (int j = 1; j < h + 1; j++)
	{
		for (int i = 1; i < w + 1; i++)
		{ // shakrs 배열을 temp(계산된 값)로 초기화한다.
			sharks[j][i].s = temp[j][i].s;
			sharks[j][i].d = temp[j][i].d;
			sharks[j][i].z = temp[j][i].z;
		}
	}
}


int flip(int cd)
{ // 상어 방향 뒤집기
	if (cd == 1) return 2;
	if (cd == 3) return 4;
	if (cd == 2) return 1;
	else return 3;
}
zips next(int min, int max, int next, int dir)
{ // 다음 위치를 정하는 함수 (핵심 함수!)
	zips answer; // 정답 크기와 방향을 리턴
	while (!(min <= next && next <= max))
	{ // 상어의 다음 위치가 상어 존재 가능 위치를 벗어나는동안 while문을 돈다.
		if (next > max)
		{ // 만약 오른쪽으로 벗어났다면
			int dist = next - max; // 벗어난 길이만큼
			next = max - dist; // 다음위치를 오른쪽에서 왼쪽으로 접어준다.
			dir = flip(dir); // 방향은 뒤집어준다.
			continue; // 넘어가기
		}
		else
		{ // 만약 왼쪽으로 벗어났다면
			int dist = min - next; // 벗어난 길이만큼
			next = dist + 1; // 오른쪽으로 접어준다. 인덱스 0이 끼어있으므로 1을 더한다.
			dir = flip(dir); // 방향은 뒤집어준다 .
		}
	}
	answer.next = next; // 다음 위치 값과
	answer.dir = dir; // 다음 방향 값을
	return answer; // 반환
}

position next_position(int cx, int cy, int cd, int speed, int w, int h)
{ // 다음 위치 정하기
	int min_x = 1; // 각각 미니멈/맥시멈 값을 정하고
	int min_y = 1;
	int max_x = w;
	int max_y = h;
	
	int nd = 0; // 다음 위치 및 방향을 초기화
	int nx = cx + dx[cd] * speed;
	int ny = cy + dy[cd] * speed;

	if (cd == 1)
	{ // 위쪽 보고 있는 상어
		zips temp;
		temp = next(min_y, max_y, ny, cd); // 다음 방향과 위치를 구함
		ny = temp.next;
		nd = temp.dir;
	}
	if (cd == 3)
	{ // 오른쪽 보고 있는 상어
		zips temp;
		temp = next(min_x, max_x, nx, cd); // 다음 방향과 위치를 구함
		nx = temp.next;
		nd = temp.dir;
	}
	if (cd == 2)
	{ // 아래 보고 있는 상어
		zips temp;
		temp = next(min_y, max_y, ny, cd); // 다음 방향과 위치를 구함
		ny = temp.next;
		nd = temp.dir;
	}
	if (cd == 4)
	{ // 왼쪽 보고 있는 상어
		zips temp;
		temp = next(min_x, max_x, nx, cd); // 다음 방향과 위치를 구함
		nx = temp.next;
		nd = temp.dir;
	}

	position result;
	result.nx = nx; // 다음 위치와 방향을 리턴
	result.ny = ny;
	result.dir = nd;

	return result;
}

int main()
{
	int H, W, M; // R: 세로길이, C: 가로길이
	scanf("%d %d %d", &H, &W, &M);
	int r, c, s, d, z;

	while (M--)
	{
		scanf("%d %d %d %d %d", &r, &c, &s, &d, &z);
		sharks[r][c].s = s; // 상어를 초기화
		sharks[r][c].d = d;
		sharks[r][c].z = z;
	}

	int fisher = 0; // 낚시꾼 초기 위치
	int answer = 0;
	while (1)
	{
		fisher++; // 낚시꾼 한 칸 이동하고
		if (fisher == W + 2)
			break; //끝점이라면 빠져나온다.

		//상어 잡기
		for (int j = 1; j < H + 2; j++)
		{
			if (sharks[j][fisher].z != 0)
			{//만약 가장 가까운 칸에 상어가 있다면
				//상어 잡는다.
				answer += sharks[j][fisher].z;
				sharks[j][fisher].d = 0;
				sharks[j][fisher].s = 0;
				sharks[j][fisher].z = 0;
				break; // 잡았으면 빠져나온다.
			}
		}
		//연산용  temp 초기화
		temp_init(W, H);
		//상어 이동
		for (int j = 1; j < H + 1; j++)
		{
			for (int i = 1; i < W + 1; i++)
			{
				if (sharks[j][i].z != 0)
				{//상어가 있다면
					int cx = i;
					int cy = j;
					int cd = sharks[j][i].d; // 현재 방향
					int cz = sharks[j][i].z; // 현재 크기
					int cs = sharks[j][i].s; // 현재 속도

					//다음 좌표 구한다.
					position npos = next_position(cx, cy, cd, cs, W, H);

					//temp에 자리 이동
					if (temp[npos.ny][npos.nx].z != 0)
					{//만약 temp에 상어 미리 존재한다면
						if (temp[npos.ny][npos.nx].z < cz)
						{ // 만약 temp 존재하는 상어 크기가 현재보다 작다면 덮어쓴다
							temp[npos.ny][npos.nx].d = npos.dir;
							temp[npos.ny][npos.nx].z = cz;
							temp[npos.ny][npos.nx].s = cs;
						}
					}
					else
					{ // temp의 자리에 상어가 없다면
						temp[npos.ny][npos.nx].d = npos.dir; // 연산된 방향과 현재 크기, 속도로 초기화
						temp[npos.ny][npos.nx].z = cz;
						temp[npos.ny][npos.nx].s = cs;
					}
				}
			}
		}
    //계산된 temp맵을 상어 맵으로 최신화
		sharks_init(W, H);
	}
	printf("%d\n", answer); // 결과 출력

	//system("pause");
	return 0;
}

#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <tuple>
#include <deque>

using namespace std;

int map[102][102]; // 맵 저장용
int check[102][102]; // 뱀 움직임 연산용
queue<pair<int, char>> moves; // 움직임 

int answer = 0;

int dx[] = { 0,1,0,-1 }; // 각각 방향을 상 우 하 좌 를 0, 1, 2, 3으로 매핑
int dy[] = { -1,0,1,0 };

void init(int N)
{ // 맵 테두리 벽 치기
	for (int i = 0; i < N; i++)
	{
		map[0][i] = -1;
		map[N - 1][i] = -1;
		check[0][i] = -1;
		check[N - 1][i] = -1;
	}
	for (int j = 0; j < N; j++)
	{
		map[j][0] = -1;
		map[j][N - 1] = -1;
		check[j][0] = -1;
		check[j][N - 1] = -1;
	}
}
int turn_right(int cd)
{ // 우회전
	if (cd == 0) return 1;
	else if (cd == 1) return 2;
	else if (cd == 2) return 3;
	else return 0;
}
int turn_left(int cd)
{ // 좌회전
	if (cd == 0) return 3;
	else if (cd == 3) return 2;
	else if (cd == 2) return 1;
	else return 0;
}

int turn(int cd, char d)
{ // 회전시키기
	if (d == 'L')
		return turn_left(cd);
	else
		return turn_right(cd);
}

void snake_move(int x, int y, int d, int N)
{ // 뱀 움직이기
	queue<pair<int, int>> snake; // 뱀 몸 좌표 저장용
	check[y][x] = 1; // 최초 위치 초기화
	snake.push(make_pair(x, y)); // snake에 현재 좌표 넣기
	int cd = d; // 현재 방향 초기화

	int time = 0;
	
	while (1)
	{	
		time++; // 시간 증가
		int cx, cy;
		cx = snake.back().first; 현재 위치 초기화
		cy = snake.back().second;
		int nx, ny;
		nx = cx + dx[cd];
		ny = cy + dy[cd];
		if (check[ny][nx] != 0 || (nx <= 0 && N + 1 <= nx && ny <= 0 && N + 1 <= ny))
		{ // 뱀의 머리가 몸에 부딧히거나 벽이면 끝낸다.
			answer = time;
			return;
		}
		check[ny][nx] = 1; // 다음 위치가 접근 가능한경우 접근
		snake.push(make_pair(nx, ny)); // 다음 위치를 큐에 넣는다.

		if (map[ny][nx] == 1)
		{//다음에 사과가 있다면
			map[ny][nx] = 0; // 사과 먹기
		}
		else
		{//사과가 없다면
			int tx, ty;
			tx = snake.front().first;
			ty = snake.front().second; // 뱀 몸이 위치하는데서 맨 꼬리값을 반환받고
			check[ty][tx] = 0; // 꼬리칸 지운다.
			snake.pop(); // 지우기
		}

		if (!moves.empty() && moves.front().first == time)
		{//움직여야 할 경우가 남아있고, 움직일(방향전환) 시간이 되었다면
			cd = turn(cd, moves.front().second); // 방향을 전환한다.
			moves.pop(); // 방향 전환 후 이전 방향값들은 pop.
		}
	}
}

int main()
{
	//
	int N, K;
	scanf("%d", &N);
	scanf("%d", &K);
	
	init(N + 2);
	
	while (K--)
	{
		int x, y;
		scanf("%d %d", &y, &x);
		map[y][x] = 1;
	}
	int L;
	scanf("%d", &L);
	
	while (L--)
	{
		int t;
		char d;
		cin >> t;
		cin >> d;
		moves.push(make_pair(t, d));
	}

	snake_move(1, 1, 1, N);
	printf("%d\n", answer);

	//system("pause");
	return 0;
}