728x90
*문제 출처는 코드트리에 있습니다.
삼멘
문제 제목: 루돌프의 반란
코드트리 | 코딩테스트 준비를 위한 알고리즘 정석
국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.
www.codetree.ai
나의 풀이
* 고려해야할 것
- 루돌프가 이동했을때, 가장 가까운 산타의 위치로 가야함. (우선순위 거리, r크기,c크기)
- 루돌프의 이동 방향은 대각선도 가능함.
루돌프와 산타가 충돌시
루돌프 -> 산타로 이동: 충돌된 산타가 C만큼 점수를 얻음
- 충돌된 산타는 대신 다음턴에 기절 함
- 산타는 충돌시에 C만큼 충돌된 방향으로 포물선을 그리며 튕겨나감 (밀려나가는 동안 그 사이에 있는 산타는 안밀림)
- 튕겨 나간 위치에 다른 산타가 있다면, 그 자리에 있던 산타는 충돌된 방향으로 +1 칸 가게되고, 그 자리에는 날아온 산타가 있음
산타가 루돌프에게 갈때
- 산타의 이동방향은 네방향이지만,(상오하좌), 루돌프에게 가까워지는게 아니면 이동 안함
- 산타 -> 루돌프 이동: 충돌된 산타가 D만큼 점수를 얻음
- 충돌된 산타는 다음턴에 기절
- 산타는 충돌시에 D만큼 충돌된 방향에서 반대방향으로 포물선을 그리며 튕겨나감 (밀려나가는 동안 그 사이에 있는 산타는 안밀림)
- 튕겨 나간 위치에 다른 산타가 있다면, 그 자리에 있던 산타는 충돌된 방향으로 +1 칸 가게되고, 그 자리에는 날아온 산타가 있음
산타는 좌표 밖으로 이동하면 사망임
산타가 좌표에 아무도 없으면 그대로 종료된다.
* 구현해야하는것
- 루돌프가 가까운 산타를 찾아 이동하는 로직
- 이때 산타와 충돌하면 산타는 루돌프가 충돌한 방향으로 날아간다.(루돌프가 때린 방향?이동한 방향?)
- 충돌 당한 산타는 다음턴에 이동X(기절)
- 산타들이 루돌프와 가까워지는 방향이 있다면 이동, 없다면 이동하지 않는 로직
- 이떄 루돌프와 충돌하면 산타는 왔던 것의 반대 방향으로 날아간다.(루돌프의 반대 방향)
- 산타가 날아가고나서 다른 산타가 있다면 연쇄적으로 한칸씩 밀리는 로직
- 충돌 당한 산타는 다음턴에 이동X(기절)
- 산타가 루돌프와 충돌되거나 밀렸을때 좌표 밖으로 나가게 된다면 산타는 아웃되는 로직
* 연쇄적으로 밀리는 코드
def collision(idx,si,sj,di,dj,T): # si,sj에서 di, dj 방향으로 산타 움직이기 T: C,D 중 하나
global santa, die, maps
# 부딪힌 산타는 T칸 뒤로 감
wake_up[idx] = Game_Turn + 2
santa[idx][2] += T # 점수 흭득
if 0 <= si + T * di < N and 0 <= sj + T * dj < N:
# 밀려날때 뒤에 산타가 있는지 확인
if maps[si + T * di][sj + T * dj] == 0:
maps[si + T * di][sj + T * dj] = idx
santa[idx][0], santa[idx][1] = si + T * di, sj + T * dj
else:
# 밀려난 뒤로 연쇄적으로 밀기
queue = deque([[si + T * di, sj + T * dj, maps[si + T * di][sj + T * dj]]])
maps[si + T * di][sj + T * dj] = idx
santa[idx][0], santa[idx][1] = si + T * di, sj + T * dj
# 원래 그자리에 있던 애가 밀려가는거
while queue:
q = queue.popleft()
qx, qy, qidx = q[0], q[1], q[2]# 이동 전 좌표
x = qx+ di
y = qy+ dj
if 0 <= x < N and 0 <= y < N:
if maps[x][y] > 0:
queue.append([x, y, maps[x][y]])
santa[qidx][0], santa[qidx][1] = x, y
maps[x][y] = qidx
else:
die[qidx] = 1 # 범위 밖으로 벗어나면 탈락 처리
else:
die[idx] = 1 # 범위 밖으로 벗어나면 탈락 처리
이전코드
더보기
from collections import deque
N, M, P, C, D = map(int,input().rstrip().split())
# M 게임 턴 수
# C 루돌프 힘
# D 산타 힘
Rr, Rc = map(int,input().rstrip().split()) # 루돌프 초기 위치
Rr, Rc = Rr-1, Rc-1
santa = {}
maps = [[0]*N for i in range(N)]
maps[Rr][Rc] = 100 # 루돌프
for i in range(P):
idx, sr, sc = map(int,input().rstrip().split())
santa[idx] = [sr-1,sc-1,0,-1] # 산타 x좌표, y좌표, 점수, 기절상태
maps[sr-1][sc-1] = idx
for i in maps:
print(i)
print()
def bfs(start, d): # 한칸씩 밀리는 로직
global santa
queue = deque([start])
while queue:
q = queue.popleft()
qx,qy = q[0],q[1]
xx = qx + d[0]
yy = qy + d[1]
if 0 <= xx < N and 0 <= yy < N :
if 0 < maps[xx][yy] < 100: # 한칸씩 밀려나면 업데이트 해줌
queue.append([xx,yy])
santa[maps[xx][yy]][0] = xx
santa[maps[xx][yy]][1] = yy
else:# 만약 범위를 벗어나면 탈락
santa[maps[qx][qy]][0] = -1
santa[maps[qx][qy]][1] = -1
# 루돌프 기준으로 좌표 찾기
def Point():
global Rr, Rc
global santa
global maps
MIN = float('INF')
min_dist = []
visited = [[False]*N for i in range(N)]
for i in santa:
sr, sc = santa[i][0], santa[i][1]
if [sr, sc] != [-1,-1]:
dist = (Rr - sr)**2 + (Rc - sc)**2
if MIN >= dist:
MIN = dist
min_dist.append([sr,sc,dist])
if not min_dist:
return
min_dist.sort(key=lambda x:(x[2],-x[0],-x[1]))
direct = ((1,0),(-1,0),(0,1),(0,-1),(1,-1),(1,1),(-1,1),(-1,-1))
MIN_R = [-1, -1,float('INF'),0,0]
for j in range(len(direct)):
nRr = Rr + direct[j][0]
nRc = Rc + direct[j][1]
if 0 <= nRc < N and 0 <= nRr < N and visited[nRr][nRc] == False:
visited[nRr][nRc] = True
min_sr = min_dist[0][0]
min_sc = min_dist[0][1]
next_dist = (nRr - min_sr)**2 + (nRc - min_sc)**2 #이쪽 방향으로 돌진
if MIN_R [2] >= next_dist:
MIN_R[2] = next_dist
MIN_R[0] = nRr
MIN_R[1] = nRc
MIN_R[3] = direct[j][0] # 루돌프가 이동한 방향
MIN_R[4] = direct[j][1] # 루돌프가 이동한 방향
# maps[Rr][Rc] = 0
Rr, Rc = MIN_R[0], MIN_R[1]
if 0 < maps[Rr][Rc] < 100:
# 산타와 루돌프 충돌
# 이 함수는 루돌프의 이동이므로 산타 점수 C 만큼 얻음
santa[maps[Rr][Rc]][2] += C
if 0 <= Rr + (MIN_R[3] * C) < N and 0 <= Rc + (MIN_R[4] * C) < N:
santa[maps[Rr][Rc]][0] = Rr + (MIN_R[3] * C)
santa[maps[Rr][Rc]][1] = Rc + (MIN_R[4] * C)
santa[maps[Rr][Rc]][3] = 1 # 산타 기절
# 연쇄적으로 밀려나기
if 0 < maps[Rr][Rc] < 100:
bfs([Rr,Rc],[MIN_R[3],MIN_R[4]])
else:
santa[maps[Rr][Rc]][0] = -1
santa[maps[Rr][Rc]][1] = -1
# 범위를 벗어났는지 확인
# 맵 세팅
new_maps = [[0]*N for i in range(N)]
for i in santa:
if santa[i][0] != -1 and santa[i][1] != -1:
new_maps[santa[i][0]][santa[i][1]] = i
new_maps[Rr][Rc] = 100
return new_maps
def santa_move():
for i in santa:
sr, sc, sp = santa[i][0], santa[i][1], santa[i][3] # 산타 위치, 산타 기절상태
if [sr, sc] != [-1, -1] or sp < 0:
# 상우하좌 우선순위
direct = ((-1,0),(0,1),(1,0),(0,-1))
for j in range(4):
nsr = sr + direct[j][0]
nsc = sc + direct[j][1]
if 0 <= nsr < N and 0 <= nsc < N:
# 이동 하는 거리가 기존 거리에서 루돌푸 있는거보다 멀어진다면
if (Rr - sr)**2 + (Rc - sc)**2 <= (Rr - nsr)**2 + (Rc - sc)**2:
continue
else:
# 가까워진다면 산타 방향 업데이트
# santa[i][0], santa[i][1] = nsr,nsc
if maps[nsr][nsc] == 100: # 이동 했는데 루돌프랑 부딪혔다면
# 산타와 루돌프 충돌
# 이 함수는 산타의 이동이므로 산타 점수 D 만큼 얻음
santa[maps[sr][sc]][2] += D
if 0 <= nsr + (direct[j][0] *(-D)) < N and 0 <= nsc + (direct[j][1] * (-D)) < N:
santa[maps[sr][sc]][0] = nsr + (direct[j][0] *(-D))
santa[maps[sr][sc]][1] = nsc + (direct[j][1] * (-D))
santa[maps[sr][sc]][3] = 1 # 산타 기절
# 연쇄적으로 밀려나기
if 0 < maps[Rr][Rc] < 100:
bfs([sr + (direct[j][0] *(-D)),sc + (direct[j][1] * (-D))], [direct[j][0] *(-D), direct[j][1] * (-D)])
else:
santa[maps[sr][sc]][0] = -1
santa[maps[sr][sc]][1] = -1
else:
santa[maps[sr][sc]][0] = nsr
santa[maps[sr][sc]][1] = nsc
break
new_maps = [[0] * N for _ in range(N)]
for i in santa:
if santa[i][0] != -1 and santa[i][1] != -1:
new_maps[santa[i][0]][santa[i][1]] = i
new_maps[Rr][Rc] = 100
return new_maps
for k in range(M):
maps = Point()
print(k,'루돌프')
for i in maps:
print(i)
print()
maps = santa_move()
print(k, '산타')
for i in maps:
print(i)
print()
die_santa = 0
for i in santa:
# 살아남은 산타들 1점 더해줌
if santa[i][0] != -1 and santa[i][1] != -1:
santa[i][2] += 1
else:
die_santa +=1
# 산타 기절 상태 업데이트
santa[i][3] -= 1
if die_santa == len(santa):
break
print(santa)
코드 피드백을 받은 뒤, 내가 너무 난잡하게 코드를 짠다는걸 깨달았다.
각각 기능별로 함수를 짜놔야 나중에 디버깅 하기 편하고,
코드를 짜기 전에 대략적인 sudo 코드를 짜는게 좋다.
그래서 코드를짜기 전에 sudo 코드를 짜줬다.
'''
sudo 코드
direction = (()) # 산타 우선순위: 상우좌하
def move():
MIN = float('INF')
MIN_direct = []
if rudolf:
# 루돌프는 산타와 가까운 방향()
dist = ()**2 + ()**2
if MIN > dist:
MIN = dist
MIN_direct = [x,y]
elif MIN == dist and x > MIN_direct[0]:
MIN_direct = [x,y]
elif MIN == dist and x == MIN_direct[0] y > MIN_direct[1]:
MIN_direct = [x,y]
else: # 산타 거리 이동 로직
def collision():
# 충돌시 구현
def move_rudolf():
move(rudolf = True) # 루돌프 - 산타 가까운 방향으로. 방향은 다름
collision(direct_idx) # 루돌프가 산타를 친 방향
def move_santa():
move(santa = True)
collision(direct_idx)
while P > 0 and M > 0:
move_rudolf()
move_santa()
cal_score() # 산타가 얻는 점수 계산, P값 계산
M -= 1
'''
구현하면서 파이참 자동 타이핑? 기능이 좋았긴했는데, 가끔 틀리게 해줘서
그냥쓰고 왜 오류가 났지 고민을 하다가 그거때문이였어서 조금 헤맸다.
그리고 코드 구현하면서 상우좌하 구현해야할 부분에서 좌표를 이상하게 적어놔서도 계속 틀렸었다.
루돌프가 이동하는 방향을 구현할때도 이전에는 bfs형식으로 구현하려했으나, 그냥 target 좌표가 있으면 해당 좌표가 내 기준으로 오른쪽, 왼쪽인지, 위,아래인지만 구현하면 쉽게 해결된다.
수정한 코드
from collections import deque
N, M, P, C, D = map(int,input().rstrip().split())
# N 맵 크기
# M 게임 턴 수
# P 산타의 수
# C 루돌프 힘
# D 산타 힘
Rr, Rc = map(int,input().rstrip().split()) # 루돌프 초기 위치
Rr, Rc = Rr -1, Rc -1
santa = {i+1:[] for i in range(P)} # 산타 위치
die = [0] * (P+1) # 산타의 생존 유무 저장 Flag
wake_up = [0] * (P+1) # 산타가 일어날 판 저장 Flag
ru_direct = ()# 루돌프의 방향
Game_Turn = 0 # 진행 게임 턴
# 산타는 한 턴에 한번만 부딪힘 주의
maps = [[0] * N for _ in range(N)] # 맵
maps[Rr][Rc] = -1
for i in range(P):
idx, sr, sc = map(int,input().rstrip().split())
sr -= 1
sc -= 1
maps[sr][sc] = idx
santa[idx] = [sr,sc,0] # 좌표, 산타 점수
def find_dir():
global Rr,Rc
global ru_direct
MIN = float('INF')
MIN_dist = []
# 루돌프는 산타와 가까운 방향으로 돌진
for i in santa:
if die[i] == 1:
continue
x = santa[i][0] # 산타 좌표
y = santa[i][1]
dist = cal_distance(x,y,Rr,Rc)
if MIN > dist:
MIN = dist
MIN_dist = [x, y]
if MIN >= dist and x > MIN_dist[0]:
MIN_dist = [x, y]
if MIN >= dist and x == MIN_dist[0] and y > MIN_dist[1]:
MIN_dist = [x, y]
# 돌격 방향 확인
Rd_x, Rd_y = 0,0 # 루돌프 방향
if Rr < MIN_dist[0]: Rd_x = 1
elif Rr > MIN_dist[0]: Rd_x = -1
if Rc < MIN_dist[1]: Rd_y = 1
elif Rc > MIN_dist[1]: Rd_y = -1
ru_direct = (Rd_x, Rd_y)
def cal_distance(px,py,nx,ny):
return ((nx - px)**2 + (ny - py)**2)
def collision(idx,si,sj,di,dj,T): # si,sj에서 di, dj 방향으로 산타 움직이기 T: C,D 중 하나
global santa, die, maps
# 부딪힌 산타는 T칸 뒤로 감
wake_up[idx] = Game_Turn + 2
santa[idx][2] += T # 점수 흭득
if 0 <= si + T * di < N and 0 <= sj + T * dj < N:
if maps[si + T * di][sj + T * dj] == 0:
maps[si + T * di][sj + T * dj] = idx
santa[idx][0], santa[idx][1] = si + T * di, sj + T * dj
else:
# 밀려난 뒤로 연쇄적으로 밀기
queue = deque([[si + T * di, sj + T * dj, maps[si + T * di][sj + T * dj]]])
maps[si + T * di][sj + T * dj] = idx
santa[idx][0], santa[idx][1] = si + T * di, sj + T * dj
# 원래 그자리에 있던 애가 밀려가는거
while queue:
q = queue.popleft()
qx, qy, qidx = q[0], q[1], q[2]# 이동 전 좌표
x = qx+ di
y = qy+ dj
if 0 <= x < N and 0 <= y < N:
if maps[x][y] > 0:
queue.append([x, y, maps[x][y]])
santa[qidx][0], santa[qidx][1] = x, y
maps[x][y] = qidx
else:
die[qidx] = 1 # 범위 밖으로 벗어나면 탈락 처리
else:
die[idx] = 1 # 범위 밖으로 벗어나면 탈락 처리
def move_rudolf():
global Rr,Rc
maps[Rr][Rc] = 0
find_dir() # 루돌프 - 산타 가까운 방향으로. 방향은 다름, 여기서 루돌프 위치 새로 갱신
next_Rr = Rr + ru_direct[0]
next_Rc = Rc + ru_direct[1]
if maps[next_Rr][next_Rc] > 0:
santa_idx = maps[next_Rr][next_Rc]
collision(santa_idx,next_Rr,next_Rc,ru_direct[0],ru_direct[1],C)
Rr,Rc = next_Rr,next_Rc
maps[Rr][Rc] = -1
def move_santa():
global maps, santa
direction = ((-1, 0), (0, 1), (1, 0), (0,-1)) # [0:4] : 산타 우선순위
# 산타 이동 로직
for i in range(1,len(santa)+1):
if die[i] == 1:
continue # 죽은 산타 PASS
if wake_up[i] > Game_Turn:
continue
sx = santa[i][0]
sy = santa[i][1]
current_dist = cal_distance(sx,sy,Rr,Rc) # 현재 산타와 루돌프의 위치 확인
MIN = float('INF')
MIN_dist = []
for j in range(4):
# 루돌프와 가까워지는 방향 찾기
nsx = sx + direction[j][0]
nsy = sy + direction[j][1]
if 0 <= nsx < N and 0 <= nsy < N and maps[nsx][nsy] <= 0:
n_dist = cal_distance(nsx,nsy,Rr,Rc)
if n_dist < current_dist and MIN > n_dist:
MIN_dist = [nsx, nsy,direction[j][0],direction[j][1]] # 루돌프와의 거리
MIN = n_dist # 루돌프와 가깝고 우선순위 높은 순으로
if MIN_dist:
nsx, nsy,di,dj = MIN_dist[0], MIN_dist[1], MIN_dist[2], MIN_dist[3]
if [nsx,nsy] == [Rr,Rc]:
maps[sx][sy] = 0 # 밀리기 전 자리는 빈칸으로
collision(i,nsx,nsy,-1 * di,-1 *dj,D)
else:
santa[i][0] = nsx
santa[i][1] = nsy
maps[sx][sy] = 0
maps[nsx][nsy] = i
while M > Game_Turn:
move_rudolf()
move_santa()
for i in range(1, P + 1):
if die[i] == 0:
santa[i][2] += 1
Game_Turn += 1
if sum(die[1:]) == P:
break
for i in range(1,P+1):
print(santa[i][2], end=' ')
문제 푸는데 총 10시간 넘게 공들인거같다..
자잘한 조건문이랑 실수가 있어서 오래걸렸다.
다시 복기해보고 열심히 해보자!! 화이팅
한번 더 복기 - 24/10/09
- 최소거리 업데이트 해줄때 break 걸면 안됨..
- 큐에 넣고 연쇄적으로 밀려날때, 밀려나는 파워가 1인경우도 고려해보셈 (이전 코드는 따로 처리 안했는데 왜그러지)
- 연쇄적으로 밀려나고 나서 새로 맵 만들때, 루돌프의 전역적인 위치 고려해보기
- 한번 더 연쇄적으로 밀려나는 코드 숙지하고 시험장가자
더보기
두번째풀이
from collections import deque
N,M,P,C,D = map(int,input().split())
# C 루돌프 힘
# D 산타 힘
rx,ry = map(int,input().split())
rx, ry = rx - 1 , ry - 1
# 산타 번호와 산타의 초기 위치 idx,sx,sy
santa = [list(map(int,input().split())) for _ in range(P)]
santa.sort(key=lambda x:x[0])
santa_score = [0] * P
alive = [1] * (P+1) # 산타의 탈락 유무 확인
alive[0] = 0
wakeup_turn = [0] * (P+1) # 산타의 기절 후 깨어날 판 확인
maps = [[0]*N for _ in range(N)]
# 게임 판 구성
maps[rx][ry] = -1 # 루돌프는 -1로 표시
for i in range(len(santa)):
idx = santa[i][0]
santa[i][1] = santa[i][1] -1
santa[i][2] = santa[i][2] - 1
x,y = santa[i][1], santa[i][2]
maps[x][y] = idx
def jump_santa(idx,x,y,di,dj,T):
global santa, maps
# 처음 충돌이 일어난 산타
queue = deque([[idx,x,y,di,dj,T]])
santa_score[idx - 1] += T # 처음 충돌 당한 산타가 얻는 점수
wakeup_turn[idx] = time + 2 # 처음 충돌 당한 산타는 두 턴 뒤에 일어난다
while queue:
cul_idx,sx,sy,dx,dy,mul = queue.popleft()
# [1] 연쇄적으로 밀릴때 해당 칸에 다른 산타가 있다면
nx,ny = sx + dx*mul, sy + dy*mul
if 0 <= nx < N and 0 <= ny < N:
if maps[nx][ny] > 0:
next_idx = maps[nx][ny]
if next_idx != cul_idx:
queue.append([next_idx,nx,ny,dx,dy,1])
santa[cul_idx-1][1], santa[cul_idx-1][2] = nx,ny
# [2] 밀려났는데 해당 칸이 빈칸이라면
elif maps[nx][ny] == 0:
santa[cul_idx-1][1], santa[cul_idx-1][2] = nx,ny
# [3] 범위 밖으로 넘어갔다면 - > alive[cur_idx] = 0
else:
alive[cul_idx] = 0
# 위치 갱신
maps = [[0] * N for _ in range(N)]
maps[rx][ry] = -1
for idx,i,j in santa:
if alive[idx] == 1:
maps[i][j] = idx
# print('T ',T, 'alive: ',alive)
# for i in maps:
# print(i)
def move_santa():
global maps,santa
direct = ((-1,0),(0,1),(1,0),(0,-1)) # 상우하좌 우선순위
for i in range(len(santa)):
idx,sx,sy = santa[i]
if alive[idx] == 1 and wakeup_turn[idx] <= time:
# 이동한 방향이 루돌프와 가까워지면 이동 -> 현재 방향과 비교
cur_dist = (rx - sx)**2 + (ry - sy)**2
MIN = float('inf')
MIN_point = []
for k in range(4):
nsx,nsy = sx + direct[k][0], sy + direct[k][1]
if 0 <= nsx < N and 0 <= nsy < N and maps[nsx][nsy] <= 0:
next_dist = (rx-nsx)**2 + (ry-nsy)**2
if cur_dist > next_dist: # 이동하는 방향이 더 가깝다면 이동함
# 근데 이동한 방향에 루돌프가 있으면 충돌 (충돌한 반대방향으로)
if MIN > next_dist:
MIN = next_dist
MIN_point = [nsx,nsy,k]
# break 이거 하면 안됨!! 더 짧은 거리를 찾을 수 있어서..
if MIN_point:
mx,my,md = MIN_point[0],MIN_point[1],MIN_point[2]
if maps[mx][my] == -1:
jump_santa(idx,mx, my, -direct[md][0], -direct[md][1], D)
# 없으면 좌표 갱신
else:
maps[mx][my] = idx
maps[sx][sy] = 0
santa[i][1],santa[i][2] = mx,my
def move_rudolf():
global maps,rx,ry
MIN = float('inf')
MIN_point = []
for i in range(len(santa)): # 산타와의 최단거리 계산
# 탈락하지 않은 산타중 가장 가까운 산타
idx,sx,sy = santa[i]
if alive[idx] == 1: # 산타가 살아있다면
# 최단거리 계산
dist = (rx - sx)**2 + (ry - sy)**2
if MIN > dist:
MIN = dist
MIN_point = [sx,sy]
elif MIN == dist and MIN_point[0] < sx:
MIN_point = [sx,sy]
elif MIN == dist and MIN_point[0] == sx and MIN_point[1] < sy:
MIN_point = [sx,sy]
# 산타에게 돌진할 방향
rdi, rdj = 0,0
if rx > MIN_point[0]:
rdi = -1
elif rx < MIN_point[0] :
rdi = 1
if ry > MIN_point[1]:
rdj = -1
elif ry < MIN_point[1]:
rdj = 1
# 산타 방향으로 한칸 이동
nrx,nry = rx + rdi, ry + rdj
# 충돌 방향에 산타가 있다면
maps[rx][ry] = 0
if maps[nrx][nry] > 0:
rx, ry = nrx, nry
sidx = maps[nrx][nry]
jump_santa(sidx,nrx,nry,rdi,rdj,C) # 산타 충돌, 해당 좌표, 충돌한 방향,얻는 점수
else:
rx, ry = nrx, nry
maps[rx][ry] = -1 # 루돌프 좌표 갱신
time = 0
while M > 0:
move_rudolf() # 루돌프 좌표 이동
if alive.count(1) == 0:
break
# print('루돌프 이동')
# for i in maps:
# print(i)
move_santa() # 산타 좌표 이동
if alive.count(1) == 0:
break
# 매턴이후 살아남은 산타에게 1점씩
for idx,x,y in santa:
if alive[idx] == 1:
santa_score[idx-1] += 1
# print('산타 이동')
# for i in maps:
# print(i)
M -= 1
time += 1
for i in santa_score:
print(i,end = " ")※ 알아야 할 것
- 복잡한 조건이 많을땐 sudo코드 먼저짜기
- 산타가 밀려날때 밀려난 좌표 조심하기 -> 계속 연습해야할듯
728x90