2-YooGyeongMo

[YooGyeongMo]

🔗 문제 링크

파이프 옮기기 1

✔️ 소요된 시간

dfs로 풀었다가 시간 초과 떠서....
dp로 생각해낼 수 없어서 풀이를 본 1인...
이건 삼성 기출 축에도 못낀다는 .... ㅠㅠ

✨ 수도 코드

문제를 먼저 읽어보시면-> 가로, 세로, 대각선 파이프를 언제 어떤 타이밍에 해당 파이프들을 놓을 수 있는지 알아볼 필요가 있습니다.

1. 가로 파이프는 이전 파이프가 가로 혹은 대각선 파이프일 때 놓을 수 있습니다.
2. 세로 파이프는 이전 파이프가 세로 혹은 대각선 파이프일 때 놓을 수 있습니닷..
3. 대각선 파이프는 이전 파이프가 세로 혹은 가로 혹은 대각선 파이프일 때 놓을 수 있습니다.

위 조건들을 체크하셨다면, 벽에 대한 조건도 고려해주셔야합니다.

• 특히 대각선 파이프를 놓으실 때 파이프를 새로 추가하는 칸뿐만 아닌 해당칸 왼쪽, 위쪽도 체크해주어야합니다.
• 첫 번째는 가로로 놓이기 때문에 첫 번째 열에는 세로로 놓일 수가 없음을 알수 있습니다 !

저는 DP를 고려할 때 2차원 배열에 가로파이프, 대각선 파이프, 세로파이프가 이전에 추가된 것들을 누적시키면서 증가 시켜서 저장하는 방식을 선택했는데요.

먼저 그림을 보시면, 2차원 배열의 한 좌표에 이러한 dp가 있다고 보시면되는데요.

아래 사진과 같은 형식으로 초기화가 되신다고 보면됩니다.

이렇게 되었을때 3차원 배열을 활용해서 [파이프 종류][행][열] 이런식으로 체크하면서 이전에 쌓인 값들을 누적하고 최종적인 [N - 1][N - 1] 에 도달하는 파이프 종류들의 방법수를 출력하면 되는 문제입니다 !

📚 새롭게 알게된 내용

저는 이 문제를 접했을 때 dfs가 생각나서 dfs로 접근하였더니, 너무 많은 조건수를 체크한 결과 ... 터졌습니다.. 앁...

아래 코드는 제가 시간초과로 터진 첫 아이디어에서 나온 dfs코드입니다.
ㅠㅠ

def move_pipe(state,r,c):
    global answer

    if r == n-1 and c == n-1:
        answer+=1
        return

    can_move_h = c + 1 < n and board[r][c+1] == 0
    can_move_v = r + 1 < n and board[r+1][c] == 0

    if state != 1 and can_move_h:
        move_pipe(0, r, c + 1)
    if state != 0 and can_move_v:
        move_pipe(1, r+1, c)
    if c + 1 < n and r + 1 < n :
        if board[r][c+1] == 0 and board[r+1][c] == 0 and board[r+1][c+1] == 0:
            move_pipe(2, r + 1, c + 1)

move_pipe(0,0,1)
print(answer)

그래서 저는 dp로 푼 문제들을 검색하였고 아래의 블로그를 참고하여 이해하고 풀었습니다 !
블로그 링크

[bishoe01]

엄청나게 깔끔하네요 전 대체 뭘하겠다고 그렇게 더럽게 된건지.. 진짜 문제에서 그냥 말한대로 해야하는 부분만 조건 적어준게 정답코드네요
재귀를 제가 좀 피하는경향이 있어서 더더욱 더러워진것같아요 . 저장해놓고 다음에 풀어봐야겠습니다..

[YooGyeongMo]

이거는 사실 dfs로 제가 풀고 시간 터진 코드입니다 ㅋㅋ file changed가시면 dp 코드있어여.... ㅠ

[bishoe01]

전 애초에 이게 DP로 풀릴거라는 생각을 전혀 못해서, 일단 경로찾기로 풀다가 각이나오기를 바랬는데, 예제는 다 맞는데 이게 시간초과 이전에 틀렸습니다가 뜨더라구요..
시간초과를 목표로 계속 조정해주다가 실패하고 보내줬습니다..

import Foundation

enum Direction {
    case down
    case right
    case diagonal
}

func solution(_ N: Int, _ graph: [[Int]]) {
    var map: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

    var queue: [(d: Direction, x: Int, y: Int)] = [(.right, 1, 2)]
    var pointer = 0
    while queue.count > pointer {
        let (d, x, y) = queue[pointer]
        map[x][y] += 1

//        var nextMoveArr: [(dd: Direction, dx: Int, dy: Int)] = [(.diagonal, 1, 1)] //대각선가려면 사방이 다 0이어야한대네 ..
        var nextMoveArr: [(dd: Direction, dx: Int, dy: Int)] = []
        if x < N, y < N,
           graph[x - 1][y] == 0,
           graph[x][y - 1] == 0,
           graph[x][y] == 0
        {
            nextMoveArr.append((.diagonal, 1, 1))
        }
        switch d {
            case .right:
                if y < N, graph[x - 1][y] == 0 {
                    nextMoveArr.append((.right, 0, 1))
                }

            case .down:
                if x < N, graph[x][y - 1] == 0 {
                    nextMoveArr.append((.down, 1, 0))
                }

            case .diagonal:
                if y < N, graph[x - 1][y] == 0 {
                    nextMoveArr.append((.right, 0, 1))
                }
                if x < N, graph[x][y - 1] == 0 {
                    nextMoveArr.append((.down, 1, 0))
                }
        }
//        print(x, y, d, nextMoveArr)
        for item in nextMoveArr {
            let (nd, nx, ny) = (item.dd, x + item.dx, y + item.dy)
            if isRange(nx, ny) {
                queue.append((d: nd, x: nx, y: ny))
            }
        }
        pointer += 1
    }
    print(map[N][N])
//    print(map)
    func isRange(_ x: Int, _ y: Int) -> Bool {
        if x < 1 || x > N || y < 1 || y > N || graph[x - 1][y - 1] == 1 {
            return false
        }
        return true
    }
}

[YooGyeongMo]

@bishoe01 오 dp처럼 접근을 엄청 잘하셨는데요 ??? 저도 dp는 무쟈게 힘들어서 회피중인데 이게 걸릴 줄이야...
핀쌤 제가 수정을 안했네예 해당 코드는 dfs고 메모이제이션으로 푼거 다시 수정해놨으예
file changed 코드보시고 한번 디피로 풀어보시지예

[alstjr7437]

아니 저도 보드문제길래 어!? BFS, DFS 이렇게 생각하고 풀었는데
시간초과였네요,,, 보드라고 무조건 BFS라는 습관을 버려야할텐데..

따로 시간을 너무 많이써서 결국 인터넷과 핀, 데미안의 코드를 참고해버렸네요 ㅠ

• 인터넷에서 참고했는데 코드가 깔끔한 것 같아서 첨부해요!

import Foundation

struct Queue<T> {
    var enq = [T]()
    var pointer = -1
    var counter = 0
    
    var isEmpty: Bool {
        counter == 0
    }
    
    mutating func append(_ element: T) {
        enq.append(element)
        counter += 1
    }
    mutating func popFirst() -> T {
        pointer += 1
        counter -= 1
        return enq[pointer]
    }
}

enum Direction {
    case horizontal
    case vertical
    case diagonal
}

let N = Int(readLine()!)!
var arr = [[Int]]()
var q = Queue<(Direction, Int, Int)>()
var answer = 0

for _ in 0..<N {
    arr.append(readLine()!.split(separator: " ").map{Int($0)!})
}

func myfunc(_ dir: Direction, _ x: Int, _ y: Int){
    if x == N-1 && y == N-1 {
        answer += 1
        return
    }
    
    var hubo = [(Direction, Int, Int)]()
    switch dir {
        case .horizontal:
            hubo = [(Direction.horizontal, x, y+1), (Direction.diagonal, x+1, y+1)]
        case .vertical:
            hubo = [(Direction.vertical, x+1, y), (Direction.diagonal, x+1, y+1)]
        case .diagonal:
            hubo = [(Direction.horizontal, x, y+1), (Direction.vertical, x+1, y), (Direction.diagonal, x+1, y+1)]
    }
    for (dire, X, Y) in hubo {
        if X >= N || Y >= N {
            continue
        }

        switch dire {
            case .horizontal, .vertical:
                if !(arr[X][Y] == 0) {
                    continue
                }
            case .diagonal:
                if !(arr[X][Y] == 0 && arr[X-1][Y] == 0 && arr[X][Y-1] == 0) {
                    continue
                }
        }
        myfunc(dire, X, Y)
    }
}

myfunc(Direction.horizontal, 0, 1)
print(answer)

[alstjr7437]

오호 이렇게 대각선까지 저장하셨군요

[YooGyeongMo]

큐와 Enum의 조화,

switch dir {
        case .horizontal:
            hubo = [(Direction.horizontal, x, y+1), (Direction.diagonal, x+1, y+1)]
        case .vertical:
            hubo = [(Direction.vertical, x+1, y), (Direction.diagonal, x+1, y+1)]
        case .diagonal:
            hubo = [(Direction.horizontal, x, y+1), (Direction.vertical, x+1, y), (Direction.diagonal, x+1, y+1)]
    }
    
    ``` 해당 방식 너무 좋은거같아요 
    
대각선 저장 방식은 DP에서 대각선을 담을땐 어떤 방식이 있을지 고민을 못했어서 코드를 참고했었네요 ㅜㅜ
    

[MuchanKim]

데미안 코드 한번 훑고 풀어서 그런지 이동 로직은 거의 똑같네요! 전 DFS로 풀었습니다.
논리적인 기능? 단위로 나눠서 풀어봤는데 나름 좋은 방법이란 생각도 드네요. 기존엔 풀어놓고 분리!
+ 길이 typealias 활용하는 거 보고 가독성 좋아지는 것 같아서 저도 함 써봄요

글구 전 문제를 풀 때 파이프를 tail과 head 두 점으로 직관적으로 표현했는데, 데미안은 head 위치와 방향 state만으로 파이프를 표현하셨군요.. 골드 문제 매우 어렵습니다. 풀이시간: 2시간+@

import Foundation

typealias Board = [[Int]]
typealias Position = (tail: (Int, Int), head: (Int, Int))

let boardSize: Int = Int(readLine()!)!

func getBoard(_ size: Int) -> Board {
    var newBoard: Board = []
    for _ in 0..<size {
        let row = readLine()!.split(separator: " ").map { Int($0)! }
        newBoard.append(row)
    }
    return newBoard
}

// 파이프의 현재 방향 확인
func getDirection(_ position: Position) -> Int {
    let (tailRow, tailCol) = position.tail
    let (headRow, headCol) = position.head
    
    // 가로 방향 (0)
    if tailRow == headRow && tailCol + 1 == headCol {
        return 0
    }
    // 세로 방향 (1)
    else if tailRow + 1 == headRow && tailCol == headCol {
        return 1
    }
    // 대각선 방향 (2)
    else {
        return 2
    }
}

// 이동 가능한지 확인
func canMove(_ position: Position, _ direction: Int, _ board: Board, _ N: Int) -> Bool {
    let (headRow, headCol) = position.head
    
    // 가로 이동
    if direction == 0 {
        let newCol = headCol + 1
        return newCol < N && board[headRow][newCol] == 0
    }
    // 세로 이동
    else if direction == 1 {
        let newRow = headRow + 1
        return newRow < N && board[newRow][headCol] == 0
    }
    // 대각선 이동
    else {
        let newRow = headRow + 1
        let newCol = headCol + 1
        return newRow < N && newCol < N && 
               board[headRow][newCol] == 0 && 
               board[newRow][headCol] == 0 && 
               board[newRow][newCol] == 0
    }
}

// 파이프 이동
func movePipe(_ position: Position, _ direction: Int) -> Position {
    let (headRow, headCol) = position.head
    
    let tail = position.head
    var head: (Int, Int) = (0, 0)
    
    // 가로 이동
    if direction == 0 {
        head = (headRow, headCol + 1)
    }
    // 세로 이동
    else if direction == 1 {
        head = (headRow + 1, headCol)
    }
    // 대각선 이동
    else {
        head = (headRow + 1, headCol + 1)
    }
    
    return (tail, head)
}

func solution(_ N: Int, _ board: Board) -> Int {
    // 시작 파이프 위치 - 처음에는 (0,0)와 (0,1) 위치에 파이프가 놓여 있음!
    let startPosition: Position = ((0, 0), (0, 1))
    var count = 0
    
    func dfs(_ position: Position) {
        // 파이프 끝이 (N-1, N-1)에 도달하면 카운트 증가
        let (headRow, headCol) = position.head
        if headRow == N-1 && headCol == N-1 {
            count += 1
            return
        }
        
        let currentDirection = getDirection(position)
        
        // 현재 방향에 따라 가능한 이동 방향 확인
        if currentDirection == 0 { // 가로
            // 가로로 이동
            if canMove(position, 0, board, N) {
                dfs(movePipe(position, 0))
            }
            // 대각선으로 이동
            if canMove(position, 2, board, N) {
                dfs(movePipe(position, 2))
            }
        }
        else if currentDirection == 1 { // 세로
            // 세로로 이동
            if canMove(position, 1, board, N) {
                dfs(movePipe(position, 1))
            }
            // 대각선으로 이동
            if canMove(position, 2, board, N) {
                dfs(movePipe(position, 2))
            }
        }
        else { // 대각선
            // 가로로 이동
            if canMove(position, 0, board, N) {
                dfs(movePipe(position, 0))
            }
            // 세로로 이동
            if canMove(position, 1, board, N) {
                dfs(movePipe(position, 1))
            }
            // 대각선으로 이동
            if canMove(position, 2, board, N) {
                dfs(movePipe(position, 2))
            }
        }
    }
    
    dfs(startPosition)
    return count
}

let board = getBoard(boardSize)
let result = solution(boardSize, board)
print(result)

[MuchanKim]

입력 간결하네예

[YooGyeongMo]

와 시간 안터지던가요 ? DFS했을때 저는 터져서 dp인걸알았는데..ㅠㅠㅠ

[YooGyeongMo]

무 코드 잘 봤습니다 !

struct Pipe {
    var tail: (Int, Int)
    var head: (Int, Int)
    
    var direction: Int {
        if tail.0 == head.0 && tail.1 + 1 == head.1 {
            return 0
        } else if tail.0 + 1 == head.0 && tail.1 == head.1 {
            return 1
        } else {
            return 2
        }
    }
    
    func moved(to newDirection: Int) -> Pipe {
        let (r, c) = head
        let newHead: (Int, Int)
        switch newDirection {
        case 0: newHead = (r, c + 1)
        case 1: newHead = (r + 1, c)
        default: newHead = (r + 1, c + 1)
        }
        return Pipe(tail: head, head: newHead)
    }
}
``` 위 코드처럼 파이프를 구조체로 두시는건 어떨까요?

이후 

```swift
let currentDirection = pipe.direction 

이런식으로 사용하면 가독성도 높아질꺼같습니다 !

[YooGyeongMo]

추가로

enum Direction: Int {
    case horizontal = 0, vertical = 1, diagonal = 2
}

``` 이런식으로도 가능할거같아요 !

[giljihun]

C2이슈로 아직 저만의 정답코드는 제출하지 못했습니다 ㅠㅠ
+
파이썬 코드 진짜 보기 좋네요 ㅋㅋㅋ
dfs도 결합된 탑다운 dp?같아요.
대각선 순회하면서 인접한 세 칸이 다 empty 조건 처리도 야무지네요!!!