na982

/*
기준점 (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;
}

#include <stdio.h>

int r, c, k;
int ret;

int map[101][101];
int pre_row_size, cur_row_size;
int pre_col_size, cur_col_size;

void update_row(int sy) {
	int bucket[101] = { 0, };
	for (int x = 1; x <= pre_col_size; ++x) {
		++bucket[map[sy][x]];
		// bucket[3] = 5 라는 의미는.
		// map[sy] row에 3이라는 값이 5번 반복되었다.
	}

	int size = 0;
	for (int i = 1; i <= 100 && size < 100; ++i) {
		for (int j = 1; j <= 100 && size < 100; ++j) {
			if (bucket[j] == i) {
				map[sy][++size] = j;
				map[sy][++size] = i;
			}
		}
	}

	for (int i = size + 1; i <= pre_col_size; ++i) {
		map[sy][i] = 0;
	}

	if (cur_col_size < size) {
		cur_col_size = size;
	}
}

void update_col(int sx) {
	int bucket[101] = { 0, };
	for (int y = 1; y <= pre_row_size; ++y) {
		++bucket[map[y][sx]];
	}

	int size = 0;
	for (int i = 1; i <= 100 && size < 100; ++i) {
		for (int j = 1; j <= 100 && size < 100; ++j) {
			if (bucket[j] == i) {
				map[++size][sx] = j;
				map[++size][sx] = i;
			}
		}
	}

	for (int i = size + 1; i <= pre_row_size; ++i) {
		map[i][sx] = 0;
	}

	if (cur_row_size < size) {
		cur_row_size = size;
	}
}

void solve() {
	while (map[r][c] != k) {
		if (cur_row_size >= cur_col_size) {
			pre_col_size = cur_col_size;
			cur_col_size = 0;
			for (int y = 1; y <= cur_row_size; ++y) {
				update_row(y);
			}
		}
		else {
			pre_row_size = cur_row_size;
			cur_row_size = 0;
			for (int x = 1; x <= cur_col_size; ++x) {
				update_col(x);
			}
		}
		++ret;
		if (ret > 100) {
			break;
		}
	}
}

int main()
{
	pre_row_size = 3, cur_row_size = 3;
	pre_col_size = 3, cur_col_size = 3;
	scanf("%d %d %d", &r, &c, &k);

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

	ret = 0;
	solve();
	if (ret > 100) {
		printf("-1\n");
	}
	else {
		printf("%d\n", ret);
	}

	return 0;
}

#include <stdio.h>

struct CELL {
	int s, d, z;
};

int r, c, m;
CELL map[2][100][100];

int fishing(int cur, int pos) {
	int size = 0;
	for (int y = 0; y < r; ++y) {
		if (map[cur][y][pos].z != 0) {
			size = map[cur][y][pos].z;
			map[cur][y][pos].s = 0;
			map[cur][y][pos].d = 0;
			map[cur][y][pos].z = 0;
			break;
		}
	}
	return size;
}

// 1 -> up
// 2 -> down
// 3 -> right
// 4 -> down
void move(int cur) {
	int next = (cur + 1) % 2;
	for (int y = 0; y < r; ++y) {
		for (int x = 0; x < c; ++x) {
			map[next][y][x].s = 0;
			map[next][y][x].d = 0;
			map[next][y][x].z = 0;
		}
	}

	for (int y = 0; y < r; ++y) {
		for (int x = 0; x < c; ++x) {
			if (map[cur][y][x].z != 0) {
				//y 감소
				if (map[cur][y][x].d == 1) {
					int ny = (((r - 1) * 2) - y) + map[cur][y][x].s;
					ny = (ny % ((r - 1) * 2));
					int nd = 2;
					if (ny >= (r - 1)) {
						ny = ((r - 1) * 2) - ny;
						nd = 1;
					}
					if (map[next][ny][x].z < map[cur][y][x].z) {
						map[next][ny][x].s = map[cur][y][x].s;
						map[next][ny][x].d = nd;
						map[next][ny][x].z = map[cur][y][x].z;
					}
				}
				//y 증가
				else if (map[cur][y][x].d == 2) {
					int ny = y + map[cur][y][x].s;
					ny = (ny % ((r - 1) * 2));
					int nd = 2;
					if (ny >= (r - 1)) {
						ny = ((r - 1) * 2) - ny;
						nd = 1;
					}
					if (map[next][ny][x].z < map[cur][y][x].z) {
						map[next][ny][x].s = map[cur][y][x].s;
						map[next][ny][x].d = nd;
						map[next][ny][x].z = map[cur][y][x].z;
					}
				}
				//x 증가
				else if (map[cur][y][x].d == 3) {
					int nx = x + map[cur][y][x].s;
					nx = (nx % ((c - 1) * 2));
					int nd = 3;
					if (nx >= (c - 1)) {
						nx = ((c - 1) * 2) - nx;
						nd = 4;
					}
					if (map[next][y][nx].z < map[cur][y][x].z) {
						map[next][y][nx].s = map[cur][y][x].s;
						map[next][y][nx].d = nd;
						map[next][y][nx].z = map[cur][y][x].z;
					}
				}
				//x 감소
				else if (map[cur][y][x].d == 4) {
					int nx = (((c - 1) * 2) - x) + map[cur][y][x].s;
					nx = (nx % ((c - 1) * 2));
					int nd = 3;
					if (nx >= (c - 1)) {
						nx = ((c - 1) * 2) - nx;
						nd = 4;
					}
					if (map[next][y][nx].z < map[cur][y][x].z) {
						map[next][y][nx].s = map[cur][y][x].s;
						map[next][y][nx].d = nd;
						map[next][y][nx].z = map[cur][y][x].z;
					}
				}
			}
		}
	}
}

int main()
{
	scanf("%d %d %d", &r, &c, &m);
	int y, x, cur = 0;
	for (int i = 0; i < m; ++i) {
		scanf("%d %d", &y, &x);
		--y, --x;
		scanf("%d %d %d", &map[cur][y][x].s, &map[cur][y][x].d, &map[cur][y][x].z);
	}

	int ret = 0;
	for (int pos = 0; pos < c; ++pos) {
		ret += fishing(cur, pos);
		move(cur);
		cur = (cur + 1) % 2;
	}
	printf("%d\n", ret);

	return 0;
}

#include <stdio.h>

int r, c, t;

int map[2][50][50];

int up_y, up_x, down_y, down_x;

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

void spead(int cur) {
	int next = (cur + 1) % 2;
	for (int y = 0; y < r; ++y) {
		for(int x = 0; x < c; ++x) {
			if (map[cur][y][x] == -1) {
				map[next][y][x] = -1;
			}
			else {
				map[next][y][x] = 0;
			}
		}
	}

	for (int y = 0; y < r; ++y) {
		for (int x = 0; x < c; ++x) {
			int val = (map[cur][y][x] / 5);
			int candi = 0;
			for (int dir = 0; dir < 4; ++dir) {
				int ny = y + dy[dir];
				int nx = x + dx[dir];

				if (ny < 0 || ny >= r || nx < 0 || nx >= c) {
					continue;
				}

				if(map[next][ny][nx] != -1) {
					map[next][ny][nx] += val;
					candi += val;
				}
			}

			if (map[next][y][x] != -1) {
				map[next][y][x] += (map[cur][y][x] - candi);
			}
		}
	}
}

void move(int cur) {
	for (int y = up_y - 1; y > 0; --y) {
		map[cur][y][0] = map[cur][y - 1][0];
	}

	for (int x = 0; x < c - 1; ++x) {
		map[cur][0][x] = map[cur][0][x + 1];
	}

	for (int y = 0; y < up_y; ++y) {
		map[cur][y][c - 1] = map[cur][y + 1][c - 1];
	}

	for (int x = c - 1; x > 1; --x) {
		map[cur][up_y][x] = map[cur][up_y][x - 1];
	}
	
	map[cur][up_y][1] = 0;


	for (int y = down_y + 1; y < r; ++y) {
		map[cur][y][0] = map[cur][y + 1][0];
	}

	for (int x = 0; x < c - 1; ++x) {
		map[cur][r - 1][x] = map[cur][r - 1][x + 1];
	}

	for (int y = r - 1; y > down_y; --y) {
		map[cur][y][c - 1] = map[cur][y - 1][c - 1];
	}

	for (int x = c - 1; x > 1; --x) {
		map[cur][down_y][x] = map[cur][down_y][x - 1];
	}

	map[cur][down_y][1] = 0;

}

int main()
{
	up_y = -1;
	scanf("%d %d %d", &r, &c, &t);
	for (int y = 0; y < r; ++y) {
		for (int x = 0; x < c; ++x) {
			scanf("%d", &map[0][y][x]);
			if (map[0][y][x] == -1) {
				if (up_y == -1) {
					up_y = y, up_x = x;
				}
				else {
					down_y = y, down_x = x;
				}
			}
		}
	}

	int cur = 0;
	for (int time = 0; time < t; ++time) {
		spead(cur);
		cur = (cur + 1) % 2;
		move(cur);
	}

	int ret = 0;
	for (int y = 0; y < r; ++y) {
		for (int x = 0; x < c; ++x) {
			if (map[cur][y][x] != -1) {
				ret += map[cur][y][x];
			}
		}
	}

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

	return 0;
}