12-alstjr7437

[alstjr7437]

🔗 문제 링크

백조의 호수

✔️ 소요된 시간

4시간 (버린 시간 2시간 30분)
플레 문제 치고 쉽다길래 도전을 했는데...
시간 초과랑 생각을 안하면 잘 풀렸는데 시간 초과가 뜨니까 머리가 ⚪️이 됐습니다..

🧐 틀린 부분

우선 문제에서 하루에 하나씩 얼음을 지워나가는 부분을 돌리고
위에 부분을 돌리고 난 후에 백조가 만날 수 있는지 테스트하면 되겠더라구요!

그래서 나온부분이 매번 visited를 매번 초기화해서 매일매일 돌리는 부분이였습니다!

1. 전체 호수 받아오기

2. 하나씩 얼음 없애는 함수 만들기

   • .이나 L부분에서 X를 만나면 한개 부수기
   • 한개 구분은 visited 배열로

3. 백조 만나는지 체크하는 함수 만들기

   • BFS로 L을 만나는지 큐에 넣으면서 쭉 체크하기
   • 만나면 day_count를 출력하고 sys.exit()로 코드 종료

4. while문으로 2~3번을 계속해서 돌아가면서 river 최신화 해주기

위와 같이 어느정도 어떻게 돌아가야할지 만들어지고 아래와 같이 코드를 짯습니다!

from collections import deque
import sys

dx = [0,0,-1,1]
dy = [1,-1,0,0]

r, c = map(int, input().split())

# 1. 전체 호수 만들기
river = []

for i in range(r):
    river.append(list(input()))

day_count = 0

# 2. 하루에 한번씩 X 없애기(얼음 없애기)
def break_ice(river):
    global day_count
    visited = [[False] * c for _ in range(r)]
    for x in range(c):
        for y in range(r):
            if river[y][x] == "." or river[y][x] == "L" :
                for i in range(4):
                    nx = x + dx[i]
                    ny = y + dy[i]
                    if nx < 0 or nx >= c or ny < 0 or ny >= r:
                        continue
                    if river[ny][nx] == "X" and visited[y][x] == False:
                        river[ny][nx] = "."
                        visited[ny][nx] = True
    
    day_count += 1
    return river
         

# 3. 백조가 만나는지 체크하기
def check_swan(river):
    queue = deque()
    meets = [[False] * c for _ in range(r)]

    
    # L을 처음 넣는 부분
    for x in range(c):
        for y in range(r):
            if river[y][x] == "L":
                swan_x = x
                swan_y = y

    queue.append([swan_y,swan_x])
    meets[swan_y][swan_x] = True

    # L과 L이 만나는지 찾는 부분
    while queue:
        y,x = queue.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= c or ny < 0 or ny >= r:
                continue
            if meets[ny][nx] == False and river[ny][nx] == "L":
                print(day_count)
                sys.exit()
            if meets[ny][nx] == False and river[ny][nx] == ".":
                queue.append([ny, nx])
                meets[ny][nx] = True
    return False

while 1:
    check_swan(river)
    river = break_ice(river)

근데 위와 같이 하게되면 시간초과가 나오더라구요
나와서 다시 생각해보니
얼음을 부술때도 river의 모든 부분을 돌리면서 시간 🆙
백조 만나는지 체크할때도 모든 부분을 다시 확인해야해서 시간 🆙
이렇게 여러가지 시간 초과를 할만한 코드를 작성했었습니다.

가로 세로 길이 1500인데 그럼 호수의 최대 크기가 대략 200만인데
200만을 계속 반복할 수도..?

⭐️ 정답

위와 같이 1, 2, 3, 4로
얼음을 부수고 백조가 만나는지 체크하는 부분은 똑같지만
한번 BFS를 한 부분은 다시 쓸일이 없고 시간 낭비만 됐습니다!!

그래서 생각한 부분이 양방향 큐를 이용해 재사용을 없애면 됐습니다!

🧊 얼음 깨지는 부분

index	0	번		1	번		2	번
0	.	L		.	L		.	L
1	.	.		.	.		.	.
2	X	X		.	.		.	.
3	X	X		X	X		.	.
4	X	X		X	X		.	.
5	X	X		.	.		.	.
6	.	.		.	.		.	.
7	.	L		.	L		.	L

위 표와 같이 움직게 되는데
따로 .부분을 다시 돌릴 필요 없이
X면 2번째 큐에 넣어주면 됐습니다.

1. .이 나오면 water1에 그대로 append해서 확장
2. X가 나오면 water2에 넣어서 저장해둠
3. .이 다 돌아가고 나면 water2에는 X였던거 중 인접한게 담아짐
4. water1과 water2를 교체하고 2를 다시 비워줌
5. 1~4 반복

위 표 예제를 들면
water1 -> 0, 1, 6, 7
water2 -> 2, 5

water1 -> 2, 5
water2 -> 3, 4

water 1 -> 3, 4

이렇게 해서 모든 얼음이 깨지게 됩니다!!!

🦢 백조 만나는지 체크하기

이부분도 위와 똑같은 방식으로 가지만 처음 넣은 백조부분부터 시작합니다.
그리고 위와 같이 진행하면서 백조가 0,1에 있으니 0,1을 pop해주고 주변 부분을 넣어줍니다.

swan1 -> 0, 1
swan2 -> 2

swan1 -> 2
swan2 -> 3

swan1 -> 3, 4, 5, 6, 7
모두 .으로 swan1에 다 push되고 다른 백조의 좌표를 만나게 됩니다.

💻 최종 코드

from collections import deque
import sys

dx = [0,0,-1,1]
dy = [1,-1,0,0]
r, c = map(int, input().split())

water1 = deque()
water2 = deque()
visited = [[False] * c for _ in range(r)]

swan1 = deque()
swan2 = deque()
visited2 = [[False] * c for _ in range(r)]

# 1. 전체 호수 만들기
river = []
for i in range(r):
    river.append(list(input()))

day_count = 0

# 2. 백조 위치 찾기와 물 위치 찾기
swan = []
for x in range(c):
    for y in range(r):
        if river[y][x] == "L":
            swan.append([y,x])
            river[y][x] = "."
        if river[y][x] == ".":
            water1.append([y, x])
            visited[y][x] = True

# 3. 백조를 큐에 추가 
swan1.append(swan[0])
visited2[swan[0][0]][swan[0][1]] = True

# 4. 하루에 한번씩 X 없애기(얼음 없애기)
def break_ice():
    # print("-------")
    while water1:
        y, x = water1.popleft()
        # print(y, x, water1, water2)
        river[y][x] = "."
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= c or ny < 0 or ny >= r:
                continue
            if not visited[ny][nx]:
                if river[ny][nx] == ".":
                    water1.append([ny,nx])
                else :
                    water2.append([ny,nx])
                visited[ny][nx] = True
                
# 5. 백조가 만나는지 체크하기
def check_swan():
    # print("-------")
    while swan1 : 
        y, x = swan1.popleft()
        # print(x,y,swan1, swan2)
        if y == swan[1][0] and x == swan[1][1]:
            print(day_count)
            sys.exit()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= c or ny < 0 or ny >= r:
                continue
            if not visited2[ny][nx]:
                if river[ny][nx] == "." and visited2[ny][nx] == False:
                    swan1.append([ny,nx])
                else :
                    swan2.append([ny,nx])
                visited2[ny][nx] = True
    return False

# 만날때까지 돌리기
while 1:
    break_ice()
    water1 = water2
    water2 = deque()

    check_swan()
    swan1 = swan2
    swan2 = deque()
    day_count += 1

📚 새롭게 알게된 내용

어떻게 구현까지는 쉽게 풀렸는데 시간초과 메모리 초과 계산을 안하니까 정말 멘붕이네요...
그래도 양방향 큐를 이용해서 재사용 시간을 줄이는 부분을 연습할 수 있어서 좋았습니다!

[9kyo-hwang]

플래 5 싀-잇

[9kyo-hwang]

확실히 다른 사람들이 제출한 코드 보니까 큐 2개를 쓰는 풀이가 많더라구요.

제 경우 유니온 파인드를 이용해서 풀었습니다. 백조의 호수 제 PR에 그림 자료 같이 첨부해놨으니 한 번 확인해보세요~

[SeongHoonC]

헐 다음 bfs 큐로 넘겨주는건 생각 못했는데..
직접 풀어볼 엄두가 안나서 설명 보면서, 코드를 따라치면서 봤습니당..
꼼꼼하게 PR 올려주셔서 감사합니다!

[wkdghdwns199]

보니까 queue 4개 써서 푸는 사람도 있더라구요.

from collections import deque
import sys
input = sys.stdin.readline



def waterMelt() :
    while waterPos :
        y,x = waterPos.popleft()
        maps[y][x] = '.'

        for dy,dx in dir :
            ny,nx = y+dy, x+dx
            if 0<=ny < r and 0 <= nx <c and not waterCheck[ny][nx] :
                if maps[ny][nx] == '.' :
                    waterPos.append((ny,nx))
                elif maps[ny][nx] == 'X' :
                    nextWaterPos.append((ny,nx))
                waterCheck[ny][nx] = True

def findSwan() :
    while swanPos :
        y,x = swanPos.popleft()

        if y == endY and x == endX :
            return True
    

        for dy,dx in dir :
            ny,nx = y + dy, x + dx
            if 0<= ny < r and 0 <= nx < c and not swanCheck[ny][nx] :
                if maps[ny][nx] == '.':
                    swanPos.append((ny,nx))
                elif maps[ny][nx] == 'X' :
                    nextSwanPos.append((ny,nx))
                swanCheck[ny][nx] = True
    return False


r,c = map(int, input().split())
maps = [list(input().strip()) for _ in range(r)]
swanCheck = [[False] * c for _ in range(r)]
waterCheck = [[False] * c for _ in range(r)]
dir = [[1,0], [-1,0], [0,1], [0,-1]]

swanPos = deque()
nextSwanPos = deque()
waterPos = deque()
nextWaterPos = deque()


for i in range(r):
    for j in range(c):
        if maps[i][j] =='L' :
            if not swanPos :
                swanPos.append((i,j))
                swanCheck[i][j] = True
            else :
                endY, endX = i,j
            maps[i][j] = '.'

            waterPos.append((i,j))
            waterCheck[i][j] = True
        elif maps[i][j] == '.':
            waterPos.append((i,j))
            waterCheck[i][j] = True


days =0
while True :
    waterMelt()
    if findSwan() : break

    swanPos = nextSwanPos
    waterPos = nextWaterPos
    nextSwanPos = deque()
    nextWaterPos = deque()

    days+=1

print(days)

[alstjr7437]

보니까 queue 4개 써서 푸는 사람도 있더라구요.
@wkdghdwns199 그럼요~ 저도 큐 4개 썻습니다