na982

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int left = 0, right = 0, ret = 0;
        unordered_map<char, int> m;
        while(right < s.size()) {
            if(m.find(s[right]) != m.end()) {
                left = max(left, m[s[right]] + 1);
            }
            ret = max(ret, right - left + 1);
            m[s[right]] = right;
            ++right;
        }
        return ret;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *dummy = new ListNode(-1);
        
        ListNode* target = dummy;
        int carry = 0;
        while(l1 || l2 || carry) {
            int l1_val = (l1) ? (l1->val) : (0);
            int l2_val = (l2) ? (l2->val) : (0);
            int sum = (l1_val + l2_val + carry);
            target->next = new ListNode(sum % 10);
            carry = sum / 10;
            
            target = target->next;
            l1 = (l1) ? (l1->next) : (l1);
            l2 = (l2) ? (l2->next) : (l2);
        }
        
        return dummy->next;
    }
};

#include <stdio.h>

struct POS {
	int y, x, d;
};

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

int n, k;
int color[12][12];
int map[12][12][5];

int pos_size;
POS pos[10];

int turn(int index) {
	POS cur = pos[index];
	POS next;
	next.y = cur.y + dy[cur.d];
	next.x = cur.x + dx[cur.d];
	next.d = cur.d;

	if (next.y < 0 || next.y >= n || next.x < 0 || next.x >= n || color[next.y][next.x] == 2) {
		next.d = (cur.d == 0 || cur.d == 2) ? (cur.d + 1) : (cur.d - 1);
		next.y = cur.y + dy[next.d];
		next.x = cur.x + dx[next.d];
		pos[index].d = next.d;
		if (next.y < 0 || next.y >= n || next.x < 0 || next.x >= n || color[next.y][next.x] == 2) {
			return map[cur.y][cur.x][0];
		}
	}

	int bottom = -1;
	int& cur_size = map[cur.y][cur.x][0];
	for (int i = 1; i <= cur_size; ++i) {
		if (map[cur.y][cur.x][i] == index) {
			bottom = i;
			break;
		}
	}

	int move[5] = { 0, };
	int& move_size = move[0];
	for (int i = bottom; i <= cur_size; ++i) {
		move[++move_size] = map[cur.y][cur.x][i];
	}
	cur_size = bottom - 1;

	if (color[next.y][next.x] == 1) {
		for (int i = 1; i <= move_size / 2; ++i) {
			int temp = move[i];
			move[i] = move[move_size - i + 1];
			move[move_size - i + 1] = temp;
		}
	}

	int& next_size = map[next.y][next.x][0];
	for (int i = 1; i <= move_size; ++i) {
		map[next.y][next.x][++next_size] = move[i];
		pos[move[i]].y = next.y;
		pos[move[i]].x = next.x;
		if (next_size >= 4) {
			return next_size;
		}
	}
	return next_size;
}

int main()
{
	scanf("%d %d", &n, &k);
	for (int y = 0; y < n; ++y) {
		for (int x = 0; x < n; ++x) {
			scanf("%d", &color[y][x]);
		}
	}
	for (int i = 0; i < k; ++i) {
		int y, x, d;
		scanf("%d %d %d", &y, &x, &d);
		--y, --x, --d;
		pos[pos_size].y = y;
		pos[pos_size].x = x;
		pos[pos_size].d = d;
		int& size = map[y][x][0];
		map[y][x][++size] = pos_size;
		++pos_size;
	}

	int loop = 0, ret = -1;
	while (loop <= 1000 && ret == -1) {
		++loop;
		for (int i = 0; i < k; ++i) {
			int h = turn(i);
			if (h >= 4) {
				ret = loop;
				break;
			}
		}
	}
	printf("%d\n", ret);

	return 0;
}

/*
기준점 (x, y)와 경계의 길이 d1, d2를 정한다. (d1, d2 ≥ 1, 1 ≤ x < x+d1+d2 ≤ N, 1 ≤ y-d1 < y < y+d2 ≤ N)
다음 칸은 경계선이다.
	(x, y), (x+1, y-1), ..., (x+d1, y-d1)
	(x, y), (x+1, y+1), ..., (x+d2, y+d2)
	(x+d1, y-d1), (x+d1+1, y-d1+1), ... (x+d1+d2, y-d1+d2)
	(x+d2, y+d2), (x+d2+1, y+d2-1), ..., (x+d2+d1, y+d2-d1)
경계선과 경계선의 안에 포함되어있는 곳은 5번 선거구이다.
5번 선거구에 포함되지 않은 구역 (r, c)의 선거구 번호는 다음 기준을 따른다.
	1번 선거구: 1 ≤ r < x+d1, 1 ≤ c ≤ y
	2번 선거구: 1 ≤ r ≤ x+d2, y < c ≤ N
	3번 선거구: x+d1 ≤ r ≤ N, 1 ≤ c < y-d1+d2
	4번 선거구: x+d2 < r ≤ N, y-d1+d2 ≤ c ≤ N
*/
#define MIN(a, b)		(((a) < (b)) ? (a) : (b))
#define MAX(a, b)		(((a) > (b)) ? (a) : (b))
#include <stdio.h>

int n, sum = 0;
int map[21][21] = { 0, };

int solve(int x, int y, int d1, int d2) {
	int temp[21][21] = { 0, };
	temp[x][y] = 5;
	//(x, y), (x+1, y-1), ..., (x+d1, y-d1)
	//(x + d2, y + d2), (x + d2 + 1, y + d2 - 1), ..., (x + d2 + d1, y + d2 - d1)
	for (int i = 1; i <= d1; ++i) {
		temp[x + i][y - i] = 5;
		temp[x + d2 + i][y + d2 - i] = 5;
	}
	//(x, y), (x + 1, y + 1), ..., (x + d2, y + d2)
	//(x + d1, y - d1), (x + d1 + 1, y - d1 + 1), ... (x + d1 + d2, y - d1 + d2)
	for (int i = 1; i <= d2; ++i) {
		temp[x + i][y + i] = 5;
		temp[x + d1 + i][y - d1 + i] = 5;
	}
	

	//1번 선거구 : 1 ≤ r < x + d1, 1 ≤ c ≤ y
	int aa = 0;
	for (int r = 1; r < x + d1; ++r) {
		for (int c = 1; c <= y; ++c) {
			if (temp[r][c] == 5) {
				break;
			}
			aa += map[r][c];
		}
	}
	//2번 선거구 : 1 ≤ r ≤ x + d2, y < c ≤ N
	int bb = 0;
	for (int r = 1; r <= x + d2; ++r) {
		for (int c = n; c > y; --c) {
			if (temp[r][c] == 5) {
				break;
			}
			bb += map[r][c];
		}
	}
	//3번 선거구 : x + d1 ≤ r ≤ N, 1 ≤ c < y - d1 + d2
	int cc = 0;
	for (int r = x + d1; r <= n; ++r) {
		for (int c = 1; c < y - d1 + d2; ++c) {
			if (temp[r][c] == 5) {
				break;
			}
			cc += map[r][c];
		}
	}

	//4번 선거구 : x + d2 < r ≤ N, y - d1 + d2 ≤ c ≤ N
	int dd = 0;
	for (int r = x + d2 + 1; r <= n; ++r) {
		for (int c = n; c >= y - d1 + d2; --c) {
			if (temp[r][c] == 5) {
				break;
			}
			dd += map[r][c];
		}
	}

	int ee = sum - aa - bb - cc - dd;

	int max_val = MAX(aa, MAX(bb, MAX(cc, MAX(dd, ee))));
	int min_val = MIN(aa, MIN(bb, MIN(cc, MIN(dd, ee))));

	return (max_val - min_val);
}

int main()
{
	scanf("%d", &n);
	for (int x = 1; x <= n; ++x) {
		for (int y = 1; y <= n; ++y) {
			scanf("%d", &map[x][y]);
			sum += map[x][y];
		}
	}

	int ret = 0x7fffffff;
	//(x+d1+d2 ≤ N, 1 ≤ y-d1 < y < y+d2 ≤ N)
	for (int x = 1; x <= n; ++x) {
		for (int y = 1; y <= n; ++y) {
			for (int d1 = 1; d1 <= n; ++d1) {
				for (int d2 = 1; d2 <= n; ++d2) {
					if (x + d1 + d2 > n)	continue;
					if (1 > y - d1)			continue;
					if (y + d2 > n)			continue;
					ret = MIN(ret, solve(x, y, d1, d2));
				}
			}
		}
	}
	printf("%d\n", ret);
	return 0;
}

#include <stdio.h>
#include <queue>
#include <algorithm>
using namespace std;

struct POS {
	int y, x, time;
};

int n, m, ret;
int map[50][50];

int pos_size;
POS pos[10];

int bfs(int pick[]) {
	int empty_count = 0;
	for (int y = 0; y < n; ++y) {
		for (int x = 0; x < n; ++x) {
			if (map[y][x] == 0) {
				++empty_count;
			}
		}
	}

	queue<POS> q;
	int visited[50][50] = { 0, };
	for (int i = 0; i < m; ++i) {
		q.push(pos[pick[i]]);
		visited[pos[pick[i]].y][pos[pick[i]].x] = 1;
	}

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

	while (!q.empty()) {
		POS cur = q.front();
		q.pop();

		if (map[cur.y][cur.x] == 0) {
			--empty_count;
		}
		if (empty_count == 0) {
			return cur.time;
		}

		POS next;
		next.time = cur.time + 1;
		for (int d = 0; d < 4; ++d) {
			next.y = cur.y + dy[d];
			next.x = cur.x + dx[d];
			if (next.y < 0 || next.y >= n || next.x < 0 || next.x >= n) {
				continue;
			}

			if (visited[next.y][next.x] == 0 && map[next.y][next.x] != 1) {
				q.push(next);
				visited[next.y][next.x] = 1;
			}
		}
	}
	return 0x7fffffff;
}

void dfs(int last_pick, int pick_count, int pick[]) {
	if(pick_count == m) {
		int candi = bfs(pick);
		if (ret > candi) {
			ret = candi;
		}
		return;
	}

	for (int i = last_pick + 1; i < pos_size; ++i) {
		pick[pick_count] = i;
		dfs(i, pick_count + 1, pick);
	}
}

int main()
{	
	scanf("%d %d", &n, &m);
	for (int y = 0; y < n; ++y) {
		for(int x = 0; x < n; ++x) {
			scanf("%d", &map[y][x]);
			if (map[y][x] == 2) {
				pos[pos_size].y = y;
				pos[pos_size].x = x;
				pos[pos_size].time = 0;
				++pos_size;
			}
		}
	}
	ret = 0x7fffffff;
	int pick[10] = { 0, };
	dfs(-1, 0, pick);
	if (ret == 0x7fffffff) {
		printf("-1\n");
	}
	else {
		printf("%d\n", ret);
	}
	return 0;
}