Spirale

#include <bits/stdc++.h>
using namespace std;
 
vector<int> ux = {0, -1, 0, 1}, uy = {1, 0, -1, 0}, dx = {0, -1, 0, 1},
            dy = {-1, 0, 1, 0};
 
const int MAX_N = 50;
int mat[MAX_N][MAX_N], num_visited = 0, n, m, k, current_distance = 0;
 
void update_distance(int x, int y) {
	if (x < 0 || x >= m || y < 0 || y >= n) return;
	num_visited++;
	mat[y][x] = min(mat[y][x], current_distance);
}
 
int main() {
	cin >> n >> m >> k;
	int x, y, z;
	vector<int> tx, ty;
	for (int i = 0; i < MAX_N; i++) {
		for (int j = 0; j < MAX_N; j++) { mat[i][j] = 1e9; }
	}
	for (int i = 0; i < k; i++) {
		cin >> x >> y >> z;
		x--;
		y--;
		swap(x, y);
		if (z == 0) {
			tx = dx;
			ty = dy;
		} else {
			tx = ux;
			ty = uy;
		}
		int direction_index = 1;
		int steps_len = 1;
		int steps_left = 2;
		current_distance = 1;
		num_visited = 0;
		update_distance(x, y);
		while (true) {
			if (num_visited >= n * m) break;
			if (steps_left == 0) {
				steps_len++;
				steps_left = 2;
			}
			for (int va = 0; va < steps_len; va++) {
				x += ty[direction_index];
				y += tx[direction_index];
				current_distance++;
				update_distance(x, y);
			}
			steps_left--;
			direction_index = (direction_index + 1) % 4;
		}
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) { cout << mat[i][j] << " \n"[j == m - 1]; }
	}
}

import java.util.*;
 
public class Spirale {
	static final int MAX_N = 50;
	static int[][] mat = new int[MAX_N][MAX_N];
	static int n, m, k, currentDistance, numVisited;
 
	static int[] ux = {0, -1, 0, 1};
	static int[] uy = {1, 0, -1, 0};
	static int[] dx = {0, -1, 0, 1};
	static int[] dy = {-1, 0, 1, 0};
 
	static void updateDistance(int x, int y) {
		if (x < 0 || x >= m || y < 0 || y >= n) { return; }
		numVisited++;
		mat[y][x] = Math.min(mat[y][x], currentDistance);
	}
 
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		k = sc.nextInt();
 
		for (int i = 0; i < MAX_N; i++) { Arrays.fill(mat[i], Integer.MAX_VALUE); }
 
		for (int i = 0; i < k; i++) {
			int x = sc.nextInt() - 1;
			int y = sc.nextInt() - 1;
			int z = sc.nextInt();
			int[] tx, ty;
 
			int temp = x;
			x = y;
			y = temp;
 
			if (z == 0) {
				tx = dx;
				ty = dy;
			} else {
				tx = ux;
				ty = uy;
			}
 
			int stepsLen = 1;
			int stepsLeft = 2;
			int directionIndex = 1;
			currentDistance = 1;
			numVisited = 0;
			updateDistance(x, y);
 
			while (numVisited < n * m) {
				if (stepsLeft == 0) {
					stepsLen++;
					stepsLeft = 2;
				}
 
				for (int va = 0; va < stepsLen; va++) {
					x += ty[directionIndex];
					y += tx[directionIndex];
					currentDistance++;
					updateDistance(x, y);
				}
 
				stepsLeft--;
				directionIndex = (directionIndex + 1) % 4;
			}
		}
 
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (mat[i][j] == Integer.MAX_VALUE) {
					System.out.print("INF ");
				} else {
					System.out.print(mat[i][j] + " ");
				}
			}
			System.out.println();
		}
 
		sc.close();
	}
}

ux = [0, -1, 0, 1]
uy = [1, 0, -1, 0]
dx = [0, -1, 0, 1]
dy = [-1, 0, 1, 0]
 
MAX_N = 50
mat = [[(float("inf"))] * MAX_N for _ in range(MAX_N)]
current_distance = 0
num_visited = 0
 
 
def update_distance(x: int, y: int):
	global num_visited
	if x < 0 or x >= m or y < 0 or y >= n:
		return
 
	num_visited += 1
	mat[y][x] = min(mat[y][x], current_distance)
 
 
n, m, k = map(int, input().split())
for _ in range(k):
	x, y, z = map(int, input().split())
	x -= 1
	y -= 1
	x, y = y, x
 
	if z == 0:
		tx, ty = dx, dy
	else:
		tx, ty = ux, uy
 
	steps_len = 1
	steps_left = 2
	current_distance = 1
	num_visited = 0
	direction_index = 1
	update_distance(x, y)
 
	while num_visited < n * m:
		if steps_left == 0:
			steps_len += 1
			steps_left = 2
 
		for _ in range(steps_len):
			x += ty[direction_index]
			y += tx[direction_index]
			current_distance += 1
			update_distance(x, y)
 
		steps_left -= 1
		direction_index = (direction_index + 1) % 4
 
for i in range(n):
	print(" ".join(map(str, mat[i][:m])))