https://www.acmicpc.net/problem/20056
\n어른 상어가 마법사가 되었고, 파이어볼을 배웠다.
\n마법사 상어가 크기가 N×N인 격자에 파이어볼 M개를 발사했다. 가장 처음에 파이어볼은 각자 위치에서 이동을 대기하고 있다. i번 파이어볼의 위치는 (ri, ci), 질량은 mi이고, 방향은 di, 속력은 si이다. 위치 (r, c)는 r행 c열을 의미한다.
\n격자의 행과 열은 1번부터 N번까지 번호가 매겨져 있고, 1번 행은 N번과 연결되어 있고, 1번 열은 N번 열과 연결되어 있다.
\n파이어볼의 방향은 어떤 칸과 인접한 8개의 칸의 방향을 의미하며, 정수로는 다음과 같다.
\n
\n마법사 상어가 모든 파이어볼에게 이동을 명령하면 다음이 일들이 일어난다.
마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 구해보자.
\n첫째 줄에 N, M, K가 주어진다.
\n둘째 줄부터 M개의 줄에 파이어볼의 정보가 한 줄에 하나씩 주어진다. 파이어볼의 정보는 다섯 정수 ri, ci, mi, si, di로 이루어져 있다.
\n서로 다른 두 파이어볼의 위치가 같은 경우는 입력으로 주어지지 않는다.
\n마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 출력한다.
\n시뮬레이션
\ndef move_fireball(count):\n # 파이어볼 수만큼 이동\n for _ in range(count):\n next_y, next_x, m, s, d = fireball.pop(0)\n # 방향과 속력에 맞게 다음 위치 계산\n for _ in range(s):\n next_x += dx[d]\n next_y += dy[d]\n # 행과 열은 1번과 N번이 연결되어 있음\n if next_x < 1: next_x = N\n elif next_x > N: next_x = 1\n if next_y < 1: next_y = N\n elif next_y > N: next_y = 1\n # 다음 파이어볼의 위치를 나타낼 grid에 append\n grid[next_y][next_x].append([m, s, d])fireball 리스트에 있는 값 수만큼 pop하면서 반복문 실행grid에 appenddef check_collision():\n for i in range(1, N+1):\n for j in range(1, N+1):\n n = len(grid[i][j])\n # grid에 값이 있을 때까지 반복문 진행\n if n == 0:\n continue\n # grid 좌표 값이 하나만 있으면 바로 append\n elif n == 1:\n m, s, d = grid[i][j].pop(0)\n fireball.append([i, j, m, s, d])\n # 둘 이상이면 문제에 주어진대로 계산\n else:\n m_sum, s_sum, dir, last_d = 0, 0, True, -1\n while grid[i][j]:\n m, s, d = grid[i][j].pop(0)\n m_sum += m\n s_sum += s\n if last_d == -1:\n last_d = d\n # 하나라도 홀수, 짝수가 섞일 경우 False 저장\n else:\n if last_d%2 != d%2: dir = False\n # 질량이 0이하면 버림\n if m_sum//5 > 0:\n if dir:\n for k in range(4):\n fireball.append([i, j, m_sum//5, s_sum//n, k*2])\n else:\n for k in range(4):\n fireball.append([i, j, m_sum//5, s_sum//n, k*2+1])grid 좌표 값이 하나만 있으면 바로 appendimport sys\nN, M, K = map(int, sys.stdin.readline().split())\nfireball = [[int(x) for x in sys.stdin.readline().split()] for _ in range(M)]\ngrid = [[[] for _ in range(N+1)] for _ in range(N+1)]\ndx = [0, 1, 1, 1, 0, -1, -1, -1]\ndy = [-1, -1, 0, 1, 1, 1, 0, -1]\nresult = 0\n\ndef move_fireball(count):\n # 파이어볼 수만큼 이동\n for _ in range(count):\n next_y, next_x, m, s, d = fireball.pop(0)\n # 방향과 속력에 맞게 다음 위치 계산\n for _ in range(s):\n next_x += dx[d]\n next_y += dy[d]\n # 행과 열은 1번과 N번이 연결되어 있음\n if next_x < 1: next_x = N\n elif next_x > N: next_x = 1\n if next_y < 1: next_y = N\n elif next_y > N: next_y = 1\n # 다음 파이어볼의 위치를 나타낼 grid에 append\n grid[next_y][next_x].append([m, s, d])\n \ndef check_collision():\n for i in range(1, N+1):\n for j in range(1, N+1):\n n = len(grid[i][j])\n # grid에 값이 있을 때까지 반복문 진행\n if n == 0:\n continue\n # grid 좌표 값이 하나만 있으면 바로 append\n elif n == 1:\n m, s, d = grid[i][j].pop(0)\n fireball.append([i, j, m, s, d])\n # 둘 이상이면 문제에 주어진대로 계산\n else:\n m_sum, s_sum, dir, last_d = 0, 0, True, -1\n while grid[i][j]:\n m, s, d = grid[i][j].pop(0)\n m_sum += m\n s_sum += s\n if last_d == -1:\n last_d = d\n # 하나라도 홀수, 짝수가 섞일 경우 False 저장\n else:\n if last_d%2 != d%2: dir = False\n # 질량이 0이하면 버림\n if m_sum//5 > 0:\n if dir:\n for k in range(4):\n fireball.append([i, j, m_sum//5, s_sum//n, k*2])\n else:\n for k in range(4):\n fireball.append([i, j, m_sum//5, s_sum//n, k*2+1])\n\nfor _ in range(K):\n move_fireball(len(fireball))\n check_collision()\nfor i in fireball:\n result += i[2]\nprint(result)처음에 문제를 제대로 이해하기가 약간 어려웠지만 주어진 예제를 손으로 풀어보니까 이해됐다
\n그 다음 구현하는 과정은 문제에서 주어진대로만 하면 돼서 나름 쉽게 해결
https://www.acmicpc.net/problem/19237
\n청소년 상어는 더욱 자라 어른 상어가 되었다. 상어가 사는 공간에 더 이상 물고기는 오지 않고 다른 상어들만이 남아있다. 상어에는 1 이상 M 이하의 자연수 번호가 붙어 있고, 모든 번호는 서로 다르다. 상어들은 영역을 사수하기 위해 다른 상어들을 쫓아내려고 하는데, 1의 번호를 가진 어른 상어는 가장 강력해서 나머지 모두를 쫓아낼 수 있다.
\nN×N 크기의 격자 중 M개의 칸에 상어가 한 마리씩 들어 있다. 맨 처음에는 모든 상어가 자신의 위치에 자신의 냄새를 뿌린다. 그 후 1초마다 모든 상어가 동시에 상하좌우로 인접한 칸 중 하나로 이동하고, 자신의 냄새를 그 칸에 뿌린다. 냄새는 상어가 k번 이동하고 나면 사라진다.
\n각 상어가 이동 방향을 결정할 때는, 먼저 인접한 칸 중 아무 냄새가 없는 칸의 방향으로 잡는다. 그런 칸이 없으면 자신의 냄새가 있는 칸의 방향으로 잡는다. 이때 가능한 칸이 여러 개일 수 있는데, 그 경우에는 특정한 우선순위를 따른다. 우선순위는 상어마다 다를 수 있고, 같은 상어라도 현재 상어가 보고 있는 방향에 따라 또 다를 수 있다. 상어가 맨 처음에 보고 있는 방향은 입력으로 주어지고, 그 후에는 방금 이동한 방향이 보고 있는 방향이 된다.
\n모든 상어가 이동한 후 한 칸에 여러 마리의 상어가 남아 있으면, 가장 작은 번호를 가진 상어를 제외하고 모두 격자 밖으로 쫓겨난다.
\n<그림 1>은 맨 처음에 모든 상어가 자신의 냄새를 뿌린 상태를 나타내며, <표 1>에는 각 상어 및 현재 방향에 따른 우선순위가 표시되어 있다. 이 예제에서는 k = 4이다. 왼쪽 하단에 적힌 정수는 냄새를 의미하고, 그 값은 사라지기까지 남은 시간이다. 좌측 상단에 적힌 정수는 상어의 번호 또는 냄새를 뿌린 상어의 번호를 의미한다.
\n
\n<그림 4>은 격자에 남아있는 모든 상어가 한 칸 이동하고 자신의 냄새를 뿌린 상태, <그림 5>는 <그림 4>에서 한 칸 더 이동한 상태를 나타낸다. 상어 2는 인접한 칸 중에 아무 냄새도 없는 칸이 없으므로 자신의 냄새가 들어있는 (2, 4)으로 이동했다. 상어가 이동한 후에, 맨 처음에 각 상어가 뿌린 냄새는 사라졌다.
이 과정을 반복할 때, 1번 상어만 격자에 남게 되기까지 몇 초가 걸리는지를 구하는 프로그램을 작성하시오.
\n첫 줄에는 N, M, k가 주어진다. (2 ≤ N ≤ 20, 2 ≤ M ≤ N2, 1 ≤ k ≤ 1,000)
\n그 다음 줄부터 N개의 줄에 걸쳐 격자의 모습이 주어진다. 0은 빈칸이고, 0이 아닌 수 x는 x번 상어가 들어있는 칸을 의미한다.
\n그 다음 줄에는 각 상어의 방향이 차례대로 주어진다. 1, 2, 3, 4는 각각 위, 아래, 왼쪽, 오른쪽을 의미한다.
\n그 다음 줄부터 각 상어의 방향 우선순위가 상어 당 4줄씩 차례대로 주어진다. 각 줄은 4개의 수로 이루어져 있다. 하나의 상어를 나타내는 네 줄 중 첫 번째 줄은 해당 상어가 위를 향할 때의 방향 우선순위, 두 번째 줄은 아래를 향할 때의 우선순위, 세 번째 줄은 왼쪽을 향할 때의 우선순위, 네 번째 줄은 오른쪽을 향할 때의 우선순위이다. 각 우선순위에는 1부터 4까지의 자연수가 한 번씩 나타난다. 가장 먼저 나오는 방향이 최우선이다. 예를 들어, 우선순위가 1 3 2 4라면, 방향의 순서는 위, 왼쪽, 아래, 오른쪽이다.
\n맨 처음에는 각 상어마다 인접한 빈 칸이 존재한다. 따라서 처음부터 이동을 못 하는 경우는 없다.
\n1번 상어만 격자에 남게 되기까지 걸리는 시간을 출력한다. 단, 1,000초가 넘어도 다른 상어가 격자에 남아 있으면 -1을 출력한다.
\n시뮬레이션
\ndef update_grid():\n for i in range(N):\n for j in range(N):\n if grid[i][j] != 0:\n # 시간 -1\n grid[i][j][1] -= 1\n # 시간이 0이면 해당 좌표 0으로 초기화\n if grid[i][j][1] == 0:\n grid[i][j] = 0def move_shark(copy_grid, n, x, y):\n check = False\n p = priority[n][cur_dir[n]-1]\n # 우선순위에 맞게 다음 위치 계산\n for p in priority[n][cur_dir[n]-1]:\n next_x = x + dx[p-1]\n next_y = y + dy[p-1]\n # 다음 위치가 boundary 안이고 0인지 확인\n if 0 <= next_x < N and 0 <= next_y < N:\n if copy_grid[next_y][next_x] == 0:\n # 실제 grid가 0일 때만 진행\n if grid[next_y][next_x] == 0:\n grid[next_y][next_x] = [n+1, k+1]\n shark[n] = (next_x, next_y)\n cur_dir[n] = p\n check = True\n break\n # 주변에 0인 칸이 없는 경우\n if not check:\n for p in priority[n][cur_dir[n]-1]:\n next_x = x + dx[p-1]\n next_y = y + dy[p-1]\n if 0 <= next_x < N and 0 <= next_y < N:\n # 자기 냄새가 있는 곳으로 돌아감\n if copy_grid[next_y][next_x][0] == n+1:\n if grid[next_y][next_x][0] == n+1:\n grid[next_y][next_x] = [n+1, k+1]\n shark[n] = (next_x, next_y)\n cur_dir[n] = p\n breakgrid가 0일 때만 grid에 [n+1, k+1] 값 넣고, 현재 상어 위치, 방향 다시 설정grid가 n+1인 경우, grid에 [n+1, k+1] 값 넣고, 현재 상어 위치, 방향 다시 설정def check_collision():\n global num\n for i in range(M):\n if shark[i] == -1:\n continue\n for j in range(i+1, M):\n # 중복되는 위치에 있으면, 숫자가 큰 상어의 위치를 -1로 초기화하고 num -1\n if shark[i] == shark[j]:\n shark[j] = -1\n num -= 1num -1while(num > 1):\n if(count >= 1000 and num > 1):\n count = -1\n break\n count += 1\n copy_grid = copy.deepcopy(grid)\n for i in range(M):\n if shark[i] != -1:\n move_shark(copy_grid, i, shark[i][0], shark[i][1])\n update_grid()\n check_collision()\nprint(count)count가 1000 이상이면서 num이 1보다 크면 count -1로 설정하고 출력grid deepcopymove_shark 함수 실행하고update_grid , check_collision 함수 실행num이 1 이하면 count 출력import sys, copy\n\nN, M, k = map(int, sys.stdin.readline().split())\ngrid = [[int(x) for x in sys.stdin.readline().split()] for _ in range(N)]\ncur_dir = [int(x) for x in sys.stdin.readline().split()]\npriority = [[[int(x) for x in sys.stdin.readline().split()] for _ in range(4)] for _ in range(M)]\nshark = [0 for _ in range(M)]\nnum = M\ncount = 0\ndx = [0, 0, -1, 1]\ndy = [-1, 1, 0, 0]\n\ndef update_grid():\n for i in range(N):\n for j in range(N):\n if grid[i][j] != 0:\n # 시간 -1\n grid[i][j][1] -= 1\n # 시간이 0이면 해당 좌표 0으로 초기화\n if grid[i][j][1] == 0:\n grid[i][j] = 0\n\ndef move_shark(copy_grid, n, x, y):\n check = False\n p = priority[n][cur_dir[n]-1]\n # 우선순위에 맞게 다음 위치 계산\n for p in priority[n][cur_dir[n]-1]:\n next_x = x + dx[p-1]\n next_y = y + dy[p-1]\n # 다음 위치가 boundary 안이고 0인지 확인\n if 0 <= next_x < N and 0 <= next_y < N:\n if copy_grid[next_y][next_x] == 0:\n # 실제 grid가 0일 때만 진행\n if grid[next_y][next_x] == 0:\n grid[next_y][next_x] = [n+1, k+1]\n shark[n] = (next_x, next_y)\n cur_dir[n] = p\n check = True\n break\n # 주변에 0인 칸이 없는 경우\n if not check:\n for p in priority[n][cur_dir[n]-1]:\n next_x = x + dx[p-1]\n next_y = y + dy[p-1]\n if 0 <= next_x < N and 0 <= next_y < N:\n # 자기 냄새가 있는 곳으로 돌아감\n if copy_grid[next_y][next_x][0] == n+1:\n if grid[next_y][next_x][0] == n+1:\n grid[next_y][next_x] = [n+1, k+1]\n shark[n] = (next_x, next_y)\n cur_dir[n] = p\n break\n\ndef check_collision():\n global num\n for i in range(M):\n if shark[i] == -1:\n continue\n for j in range(i+1, M):\n # 중복되는 위치에 있으면, 숫자가 큰 상어의 위치를 -1로 초기화하고 num -1\n if shark[i] == shark[j]:\n shark[j] = -1\n num -= 1\n\nfor i in range(N):\n for j in range(N):\n if grid[i][j] != 0:\n grid[i][j] = [grid[i][j], k]\n shark[grid[i][j][0]-1] = (j, i)\n\nwhile(num > 1):\n if(count >= 1000 and num > 1):\n count = -1\n break\n count += 1\n copy_grid = copy.deepcopy(grid)\n for i in range(M):\n if shark[i] != -1:\n move_shark(copy_grid, i, shark[i][0], shark[i][1])\n update_grid()\n check_collision()\nprint(count)문제에서 주어진대로만 구현하면 돼서 구현에 크게 문제는 없었지만 시간이 조오금 걸렸다
\n시간을 어떻게 줄이면서 풀지는 차근차근 문제 많이 풀어보면서 생각해봐야지,,
https://www.acmicpc.net/problem/20057
\n마법사 상어가 토네이도를 배웠고, 오늘은 토네이도를 크기가 N×N인 격자로 나누어진 모래밭에서 연습하려고 한다. 위치 (r, c)는 격자의 r행 c열을 의미하고, A[r][c]는 (r, c)에 있는 모래의 양을 의미한다.
\n토네이도를 시전하면 격자의 가운데 칸부터 토네이도의 이동이 시작된다. 토네이도는 한 번에 한 칸 이동한다. 다음은 N = 7인 경우 토네이도의 이동이다.
\n
\n토네이도가 한 칸 이동할 때마다 모래는 다음과 같이 일정한 비율로 흩날리게 된다.
\n
\n토네이도가 x에서 y로 이동하면, y의 모든 모래가 비율과 α가 적혀있는 칸으로 이동한다. 비율이 적혀있는 칸으로 이동하는 모래의 양은 y에 있는 모래의 해당 비율만큼이고, 계산에서 소수점 아래는 버린다. α로 이동하는 모래의 양은 비율이 적혀있는 칸으로 이동하지 않은 남은 모래의 양과 같다. 모래가 이미 있는 칸으로 모래가 이동하면, 모래의 양은 더해진다. 위의 그림은 토네이도가 왼쪽으로 이동할 때이고, 다른 방향으로 이동하는 경우는 위의 그림을 해당 방향으로 회전하면 된다.
토네이도는 (1, 1)까지 이동한 뒤 소멸한다. 모래가 격자의 밖으로 이동할 수도 있다. 토네이도가 소멸되었을 때, 격자의 밖으로 나간 모래의 양을 구해보자.
\n첫째 줄에 격자의 크기 N이 주어진다. 둘째 줄부터 N개의 줄에는 격자의 각 칸에 있는 모래가 주어진다. r번째 줄에서 c번째 주어지는 정수는 A[r][c] 이다.
\n격자의 밖으로 나간 모래의 양을 출력한다.
\n시뮬레이션
\ndef move_tornado():\n x, y = N//2, N//2\n count = 0\n while True:\n # 좌, 하, 우, 상 순서로 반복\n for d in range(4):\n # 좌 or 우 경우에는 count +1\n if d%2 == 0:\n count += 1\n # count 만큼 해당 방향으로 이동 반복\n for _ in range(count):\n x, y = x+dx[d], y+dy[d]\n move_sand(x, y, d)\n # 0, 0 에서 멈춤\n if x == 0 and y == 0: returncount +1move_sand 함수 실행하고def move_sand(x, y, d):\n global result\n sand = A[y][x]\n # 주어진 규칙대로 모래 흩날림\n A[y][x] -= cal_moved_sand(x+dx[d]*2, y+dy[d]*2, 0.05, sand)\n A[y][x] -= cal_moved_sand(x+dx[d]+dx[(d+3)%4], y+dy[d]+dy[(d+3)%4], 0.1, sand)\n A[y][x] -= cal_moved_sand(x+dx[d]+dx[(d+1)%4], y+dy[d]+dy[(d+1)%4], 0.1, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+3)%4]*2, y+dy[(d+3)%4]*2, 0.02, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+3)%4], y+dy[(d+3)%4], 0.07, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+1)%4], y+dy[(d+1)%4], 0.07, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+1)%4]*2, y+dy[(d+1)%4]*2, 0.02, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+2)%4]+dx[(d+3)%4], y+dy[(d+2)%4]+dy[(d+3)%4], 0.01, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+2)%4]+dx[(d+1)%4], y+dy[(d+2)%4]+dy[(d+1)%4], 0.01, sand)\n # 알파 계산\n if 0 <= x+dx[d] < N and 0 <= y+dy[d] < N:\n A[y+dy[d]][x+dx[d]] += A[y][x]\n else:\n result += A[y][x]\n A[y][x] = 0cal_moved_sand 함수 실행def cal_moved_sand(next_x, next_y, percent, sand):\n global result\n # boundary 안인지 밖인지 확인\n if 0 <= next_x < N and 0 <= next_y < N:\n A[next_y][next_x] += int(percent * sand)\n else:\n result += int(percent * sand)\n return int(percent * sand)import sys\nN = int(sys.stdin.readline())\nA = [[int(x) for x in sys.stdin.readline().split()]for _ in range(N)]\n# 좌, 하, 우, 상\ndx = [-1, 0, 1, 0]\ndy = [0, 1, 0, -1]\nresult = 0\n\ndef cal_moved_sand(next_x, next_y, percent, sand):\n global result\n # boundary 안인지 밖인지 확인\n if 0 <= next_x < N and 0 <= next_y < N:\n A[next_y][next_x] += int(percent * sand)\n else:\n result += int(percent * sand)\n return int(percent * sand)\n\ndef move_sand(x, y, d):\n global result\n sand = A[y][x]\n # 주어진 규칙대로 모래 흩날림\n A[y][x] -= cal_moved_sand(x+dx[d]*2, y+dy[d]*2, 0.05, sand)\n A[y][x] -= cal_moved_sand(x+dx[d]+dx[(d+3)%4], y+dy[d]+dy[(d+3)%4], 0.1, sand)\n A[y][x] -= cal_moved_sand(x+dx[d]+dx[(d+1)%4], y+dy[d]+dy[(d+1)%4], 0.1, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+3)%4]*2, y+dy[(d+3)%4]*2, 0.02, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+3)%4], y+dy[(d+3)%4], 0.07, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+1)%4], y+dy[(d+1)%4], 0.07, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+1)%4]*2, y+dy[(d+1)%4]*2, 0.02, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+2)%4]+dx[(d+3)%4], y+dy[(d+2)%4]+dy[(d+3)%4], 0.01, sand)\n A[y][x] -= cal_moved_sand(x+dx[(d+2)%4]+dx[(d+1)%4], y+dy[(d+2)%4]+dy[(d+1)%4], 0.01, sand)\n # 알파 계산\n if 0 <= x+dx[d] < N and 0 <= y+dy[d] < N:\n A[y+dy[d]][x+dx[d]] += A[y][x]\n else:\n result += A[y][x]\n A[y][x] = 0\n\ndef move_tornado():\n x, y = N//2, N//2\n count = 0\n while True:\n # 좌, 하, 우, 상 순서로 반복\n for d in range(4):\n # 좌 or 우 경우에는 count +1\n if d%2 == 0:\n count += 1\n # count 만큼 해당 방향으로 이동 반복\n for _ in range(count):\n x, y = x+dx[d], y+dy[d]\n move_sand(x, y, d)\n # 0, 0 에서 멈춤\n if x == 0 and y == 0: return\n\nmove_tornado()\nprint(result)문제 보고 어렵지 않게 규칙을 찾을 수 있어서 쉽게 구현할 수 있었다.
\n주어진 규칙대로 구현은 쉬웠지만 원래 이런 문제인건지 코드는 안예쁨,,