na982

#include <stdio.h>
#include <vector>
using namespace std;

struct FIREBALL {
	int y, x;
	int m, s, d;
};

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

int N, M, K;
vector<FIREBALL> ball;
vector<int> map[50][50];

void move() {
	vector<int> new_map[50][50];
	for (int i = 0; i < ball.size(); ++i) {
		int dir = ball[i].d;
		int speed = (ball[i].s % N);
		int ny = (ball[i].y + (dy[dir] * speed) + N) % N;
		int nx = (ball[i].x + (dx[dir] * speed) + N) % N;
		new_map[ny][nx].push_back(i);
		ball[i].y = ny;
		ball[i].x = nx;
	}

	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < N; ++x) {
			map[y][x] = new_map[y][x];
		}
	}
}

void sum() {
	vector<FIREBALL> new_ball;
	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < N; ++x) {
			if (map[y][x].size() == 0) {
				continue;
			}
			if (map[y][x].size() == 1) {
				int index = map[y][x][0];
				new_ball.push_back(ball[index]);
				continue;
			}
			int sum_m = 0, sum_s = 0;
			bool odd = true, even = true;
			for (int i = 0; i < map[y][x].size(); ++i) {
				int index = map[y][x][i];
				sum_m += ball[index].m;
				sum_s += ball[index].s;
				if (ball[index].d % 2 == 0) {
					odd = false;
				}
				else {
					even = false;
				}
			}

			if (sum_m / 5 == 0) {
				continue;
			}
			int cur_m = sum_m / 5;
			int cur_s = sum_s / map[y][x].size();
			for (int i = 0; i < 4; ++i) {
				if (odd || even) {
					new_ball.push_back({ y, x, cur_m, cur_s, i * 2 });
				}
				else {
					new_ball.push_back({ y, x, cur_m, cur_s, i * 2 + 1 });
				}
			}
		}
	}

	ball = new_ball;
}

int solve() {
	while(K--) {
		move();
		sum();
	}
	int ret = 0;
	for (int i = 0; i < ball.size(); ++i) {
		ret += ball[i].m;
	}
	return ret;
}

int main()
{
	scanf("%d %d %d", &N, &M, &K);
	for (int i = 0; i < M; ++i) {
		int y, x, m, s, d;
		scanf("%d %d %d %d %d", &y, &x, &m, &s, &d);
		--y, --x;
		ball.push_back({ y, x, m, s, d });
		map[y][x].push_back(i);
	}
	int ret = solve();
	printf("%d\n", ret);
	return 0;
}

#include <stdio.h>

int N, K; 
int A[200];

int solve() {
	int ret = 0;
	int zero_count = 0;
	int robot[200 * 1000];
	int front = 0, back = 0;

	while (zero_count < K) {
		++ret;

		int temp = A[2 * N - 1];
		for (int i = 2 * N - 1; i >= 1; --i) {
			A[i] = A[i - 1];
		}
		A[0] = temp;
		for (int i = front; i < back; ++i) {
			++robot[i];
			if (robot[i] == N - 1) {
				++front;
			}
		}

		for (int i = front; i < back; ++i) {
			int next = robot[i] + 1;
			if (A[next] == 0 || (i != front && robot[i - 1] == next)) {
				continue;
			}
			robot[i] = next;
			if (robot[i] == N - 1) {
				++front;
			}
			--A[next];
			if (A[next] == 0) {
				++zero_count;
			}
		}

		if (A[0] > 0 && (back == 0 || robot[back - 1] != 0)) {
			robot[back++] = 0;
			--A[0];
			if (A[0] == 0) {
				++zero_count;
			}
		}
	}

	return ret;
}

int main()
{
	scanf("%d %d", &N, &K);
	for (int i = 0; i < N; ++i) {
		scanf("%d %d", &A[i * 2], &A[i * 2 + 1]);
	}
	int ret = solve();
	printf("%d\n", ret);
	return 0;
}

#include <stdio.h>

const int DEL = -1;
int N, M, T;
int board[50][50];

void solve(int x, int d, int k) {
	int pick = x - 1;
	if (d == 1) {
		k = -k;
	}
	while (pick < N) {
		int temp[50] = { 0, };
		for (int i = 0; i < M; ++i) {
			temp[(i + k + M) % M] = board[pick][i];
		}

		for (int i = 0; i < M; ++i) {
			board[pick][i] = temp[i];
		}
		pick += x;
	}

	bool is_update = false;
	const int dy[4] = { -1, +1, 0, 0 };
	const int dx[4] = { 0, 0, -1, +1 };
	bool check[50][50] = { false, };

	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < M; ++x) {
			for (int d = 0; d < 4; ++d) {
				int ny = y + dy[d];
				int nx = (x + dx[d] + M) % M;
				if (ny < 0 || ny >= N) {
					continue;
				}
				if (board[y][x] != DEL && board[ny][nx] != DEL && board[y][x] == board[ny][nx]) {
					is_update = true;
					check[y][x] = true;
					check[ny][nx] = true;
				}

			}
		}
	}

	if (is_update) {
		for (int y = 0; y < N; ++y) {
			for (int x = 0; x < M; ++x) {
				if (check[y][x]) {
					board[y][x] = DEL;
				}
			}
		}
	}
	else {
		int sum = 0, count = 0;
		for (int y = 0; y < N; ++y) {
			for (int x = 0; x < M; ++x) {
				if (board[y][x] != DEL) {
					sum += board[y][x];
					++count;
				}
			}
		}
		for (int y = 0; y < N; ++y) {
			for (int x = 0; x < M; ++x) {
				if (board[y][x] != DEL) {
					if (board[y][x] * count > sum) {
						--board[y][x];
					}
					else if (board[y][x] * count < sum) {
						++board[y][x];
					}
				}
			}
		}
	}
}

int main()
{
	scanf("%d %d %d", &N, &M, &T);
	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < M; ++x) {
			scanf("%d", &board[y][x]);
		}
	}
	for (int i = 0; i < T; ++i) {
		int x, d, k;
		scanf("%d %d %d", &x, &d, &k);
		solve(x, d, k);
	}
	int ret = 0;
	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < M; ++x) {
			if (board[y][x] != DEL) {
				ret += board[y][x];
			}
		}
	}
	printf("%d\n", ret);
	return 0;
}

#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;
}