27-SeongHoonC

[SeongHoonC]

🔗 문제 링크

피리 부는 사나이

오늘의 한 컷

피리 부는 성우를 위해 한 컷

✔️ 소요된 시간

40분

✨ 수도 코드

방향끼리 연결된 개수를 정하면 되는 문제라고 생각했습니다.

처음엔 dfs 로 풀려고 했었는데요.

현재 구역으로 오는 방향을 알 수 있으면 bfs 로 해도 풀리지 않을까? 라는 생각을 했습니다.

예를 들어 이런 모양이라면

현위치로 가리키는 구역과 다음 구역을 큐에 추가하는 식입니다.

그래서 방향과 해당 방향, 그리고 반대 방향을 저장해놓고

val dx = listOf(1, 0, 0, -1)
val dy = listOf(0, 1, -1, 0)
val dD = listOf("D", "R", "L", "U")
val dDInverse = listOf("U", "L", "R", "D")

조건문으로 해당되는 구역을 큐에 추가하도록 했습니다.

// bfs 로 같은 사이클에 존재하는 애들 다 찾기
private fun findSafeZone(x: Int, y: Int, n: Int, m: Int): Boolean {
    if (visited[x][y]) return false
    val q = ArrayDeque<Pair<Int, Int>>()
    q.add(x to y)
    while (q.isNotEmpty()) {
        val now = q.removeFirst()
        val nowDirection = dD.indexOf(graph[now.first][now.second])
        for (i in 0..3) {
            val nextX = now.first + dx[i]
            val nextY = now.second + dy[i]

            // 범위 넘어감
            if (nextX >= n || nextY >= m || nextX < 0 || nextY < 0) continue

            // 이미 방문함
            if (visited[nextX][nextY]) continue

            // 현재 구역의 다음 방향 or 현재 구역으로 이동할 구역이면
            if (dDInverse[i] == graph[nextX][nextY] || i == nowDirection) {
                visited[nextX][nextY] = true
                q.add(nextX to nextY)
            }
        }
    }
    return true
}

📚 새롭게 알게된 내용

[tgyuuAn]

문제 보자마자 아 같은 사이클을 도는 애들을 카운팅하면 되겠구나!

해서 BFS를 바로 떠올렸씁니다.

근데 이제

3 4 DLLL DRLL RRUL

같은 경우는 어디를 두어도 (1,1) 지점으로 수렴하기 때문에 1이 나와야하는데,

(1,3), (2,3) 지점에서 BFS를 돌리면 또 새로운 사이클로 인식하기 때문에 visited를 이용해서 조금 더 처리해주어서 풀었씁니다!

재미지다 키키키킼

import sys
from collections import deque

N, M = map(int, input().split())
board = [list(input()) for _ in range(N)]
visited = set()
answer = 0

for row in range(N):
    for col in range(M):
        if (row, col) in visited: continue

        answer += 1
        deq = deque()
        visited.add((row, col))
        inner_visited = {(row, col),}
        deq.append((row, col))
        while deq:
            now_row, now_col = deq.popleft()
            new_row, new_col = now_row, now_col

            if board[now_row][now_col] == "D":
                new_row += 1
            
            elif board[now_row][now_col] == "U":
                new_row -= 1

            elif board[now_row][now_col] == "L":
                new_col -= 1

            elif board[now_row][now_col] == "R":
                new_col += 1
            
            if (new_row, new_col) in inner_visited: break

            if (new_row, new_col) in visited: 
                answer -= 1
                break
            
            visited.add((new_row, new_col))
            inner_visited.add((new_row, new_col))
            deq.append((new_row, new_col))
        
print(answer)

[tgyuuAn]

오호라 주변을 탐색해서 같은 사이클을 돌면 체크해주는 식으로 풀었꾼요... 신기방기다

[alstjr7437]

처음에는 아래와 같이 BFS로 했는데 계속 틀려서 일단 잠시 두고

틀린 부분

from collections import deque
import sys

input = sys.stdin.readline

n, m = map(int, input().split())
graph = [list(input()) for _ in range(n)]
visited = [[0] * m for _ in range(n)] 
result = 0

for y in range(n):
    for x in range(m):
        if(visited[y][x] == 1): 
            continue
        queue = deque([(x,y)])
        visited[y][x] = 1
        while queue:
            x, y = queue.popleft()
            nx, ny = x, y
            if graph[y][x] == "U":
                ny -= 1
            elif graph[y][x] == "D":
                ny += 1
            elif graph[y][x] == "L":
                nx -= 1
            elif graph[y][x] == "R":
                nx += 1
            if ny >= n or ny < 0 or nx >= m or nx < 0 : 
                continue
            if visited[ny][nx] == 1:
                result += 1
                break
            visited[ny][nx] = 1
            queue.append((nx,ny))

print(result)

일단 DFS로 바꿔서 사이클 카운트 하는 방식으로 바꿨습니다!

기본 로직은 같지만 사이클이 생기면 result += 1을 하게 하거나 사이클이 아니면 다음 위치로 DFS가 되도록 진행했습니다.

from collections import deque
import sys

input = sys.stdin.readline

n, m = map(int, input().split())
graph = [list(input()) for _ in range(n)]
visited = [[0] * m for _ in range(n)] 
result = 0


def dfs(x,y):
    global result

    visited[y][x] = 1
    cycle.append([x, y])

    if graph[y][x] == "U":
        y -= 1
    elif graph[y][x] == "D":
        y += 1
    elif graph[y][x] == "L":
        x -= 1
    elif graph[y][x] == "R":
        x += 1

    if visited[y][x] == 1:
        if [x, y] in cycle:
            result += 1
    else :
        dfs(x,y)

for y in range(n):
    for x in range(m):
        if(visited[y][x] == 0): 
            cycle = []
            dfs(x, y)

print(result)

[alstjr7437]

오,, 반대방향도 이용하는 방법이 있군요...
처음에는 DRLU와 dx,dy와 연관이 있는줄 알고 햇갈렸네요

[H0ngJu]

Safe Zone 어케 찾지 하고 그림 그리다보니까,,
결국 Safe Zone이 의미하는게 주어진 grid에서 존재하는 서클 수를 의미하더라고요!

그래서 저는 grid의 서클 수를 찾아 반환하는 식으로 풀었습니다.

그래서 이건 틀릴 수가 없다하고 제출했는데 틀렸습니다가 뜨길래
???????왜지?????? 하고 다른 분들의 의견을 구하고자 .. 주석을 달았는데

값을 잘못 업데이트 시켜줘서 틀렸다는걸 알고 다시 고쳐서 제출했더니
통과했습니다 ㅎㅎ

보통의 DFS, BFS 문제와 다르게
이번 문제는
전 노드의 주변 위치 탐색으로는 Safe Zone을 못찾겠는데? 라고 생각했는데
주변 위치 이동하면서 현재방향과 일치하는지 보면 되는 군요 ..?

생각치 못한 접근 방식인데 알아갑니당

문제 재밌네용 수고하셨습니다 ~~~~~

import sys
from collections import deque

def input() : return sys.stdin.readline().rstrip()

N, M = map(int, input().split())

grid = [[i for i in input()] for _ in range(N)]
visited = [[0 for _ in range(M)] for _ in range(N)]
q = deque()
circle_cnt = 0 # 최종적인 서클의 수
step = circle_cnt + 1 # n 번째 서클임

for i in range(N):
    for j in range(M):
        # q에 아무것도 없는 경우
        if visited[i][j] == 0:
            q.append((i,j,grid[i][j]))
            visited[i][j] = step

        while q:
            cx, cy, letter = q.popleft() # 현재 위치

            # 다음 위치
            if letter == "R":
                nx = cx 
                ny = cy + 1
            elif letter == "L":
                nx = cx
                ny = cy - 1
            elif letter == "U":
                nx = cx - 1
                ny = cy
            else: # letter == "D"
                nx = cx + 1
                ny = cy
            
            if 0<= nx < N and 0<= ny < M: # 좌표가 범위 내에 있으면
                if visited[nx][ny] < step and visited[nx][ny] != 0:
                    # 이미 존재하는 서클에 종속되는 경우 (이미 있는 서클은 항상 현재 step보다 작고 0이 아님)
                    visited[cx][cy] = visited[nx][ny] # 종속시킴
                    step += 1 # 다음 스텝 증가
                    continue
                if visited[nx][ny] == step: # 완전한 서클 하나 찾은 경우 -> 다음 서클 찾기 위해 step + 1
                    circle_cnt += 1
                    step += 1
                    continue
                if visited[nx][ny] == 0: # 아직 미방문 노드인 경우
                    visited[nx][ny] = step
                    q.append((nx, ny, grid[nx][ny]))

print(circle_cnt)