Jenikeju

내가 푼 풀이

- 처음에는 주어진 질문에대한 모든 경우의 수에서 팰린드롬인지 구하려고 했지만, 수열의 크기를 감안했을 때 시간초과가 날 거라 생각했다.

- dp를 이용하여 dp 배열에 저장하고, 질문들을 해당 배열에서 꺼내오려한다.

- dp에 저장하기 위해 팰린드롬의 성질을 좀 더 생각해봐야 했다.

- 여기서 이용했던 팰린드롬의 성질은 주어진 수열에서 s번째부터 e까지의 수열이 팰린드롬이라면, s+1번째부터 e-1까지의 수열도 역시 팰린드롬이 된다.

- 예로 위에 주어진 수열 1, 2, 1, 3, 1, 2, 1에서 0번째부터 6번째까지의 수열이 1, 2, 1, 3, 1, 2, 1이고, 해당 수열은 팰린드롬이다.

- 0번째부터 6번째까지의 수열이 팰린드롬이라면, 1번째부터 5번째까지의 수열도 역시 팰린드롬이다. ( 2, 1, 3, 1, 2 )

- 위의 성질을 이용하기 위해선 주어진 수열의 길이가 최소 3이어야 한다.

- 수열의 길이가 1이라면 원소 자기 자신하나로 팰린드롬이 된다.

- 수열의 길이가 2라면 원소 하나와 그다음 원소가 같다면, 팰린드롬이 된다.

- 수열의 길이가 3 미만인 경우의 수는 위와 같이 구하고, 3 이상인 경우는 아래와 같이 구한다.

- dp [i][j] = i번째부터 j번째까지의 수열이 팰린드롬인가? ( 팰린드롬이라면 1을 저장, 아니라면 0을 저장)

- 위 성질을 이용하여 수열의 길이가 3이상이라면, 두가지 경우의 수를 판단하면된다.

1. 수열의 양 끝 원소가 같은지?

2. 주어진 수열의 s+1번째부터 e-1까지의 수열이 팰린드룸인지?

해당 문제는 많은 입력과 출력을 요구하므로, readLine을 이용한 입력및 print 출력을 남용하면 시간초과가 뜬다.

더 빠른 FileIO를 이용하여 입력 및 한 문자열에 저장하여 한번에 출력하는 방식을 이용한다.

코드로 구현해보자.

import Foundation

// Swift 입출력
final class FileIO {
    private var buffer:[UInt8]
    private var index: Int
    
    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(fileHandle.readDataToEndOfFile())+[UInt8(0)]
        index = 0
    }
    
    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        
        return buffer.withUnsafeBufferPointer { $0[index] }
    }
    
    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true
        
        while now == 10
                || now == 32 { now = read() }
        if now == 45{ isPositive.toggle(); now = read() }
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }
        
        return sum * (isPositive ? 1:-1)
    }
    
    @inline(__always) func readString() -> String {
        var str = ""
        var now = read()
        
        while now == 10
                || now == 32 { now = read() }
        
        while now != 10
                && now != 32 && now != 0 {
            str += String(bytes: [now], encoding: .ascii)!
            now = read()
        }
        
        return str
    }
}

// 입력
let fileIO = FileIO()
let N = fileIO.readInt()
var arr = [Int]()
for i in 0..<N {
    arr.append(fileIO.readInt())
}
let M = fileIO.readInt()
var dp = Array(repeating: Array(repeating: 0, count: N), count: N)

// 수열의 길이가 1일때
for i in 0..<N {
    dp[i][i] = 1
}

// 수열의 길이가 2일때
for i in 0..<N-1 {
    if arr[i] == arr[i+1] {
        dp[i][i+1] = 1
    }
}

// 수열의 길이가 3이상일때
for i in (0..<N-2).reversed() {
    for j in (i+2..<N).reversed() {
        let idx = j
        if arr[i] == arr[idx] && dp[i+1][idx-1] == 1 {
            dp[i][idx] = 1
        }
    }
}
var answer = ""
for i in 0..<M {
    let s1 = fileIO.readInt()
    let s2 = fileIO.readInt()
    answer += "\(dp[s1-1][s2-1])\n"
}

print(answer)

내가 푼 풀이

- 첫 시도로 백트래킹을 이용해 0,0 지점에서 N, M 지점까지 가는 경우의 수를 조사했지만, 시간초과가 떴다.

- 이전에 지나갔던 지점을 1로 변경하며 세 보았는데 이론적으로 틀린것 같다.

- 벽을 단 한번 부술 수 있지만, 벽을 아예 부수지 않아도 최단경로가 나올 수 있다.

- 이를 두가지 경우의 수로 최적의 경로를 탐색보다는 기록하는 방향으로 정했다.

- m 과 n은 최대 1000이므로 BFS로 딱 한번 탐색해내야 한다.

- 3차원 배열을 지정해 벽을 부순경우와 부수지 않은 경우 모두 기록하여 M, N 지점에 도달했을 때, 최단경로를 출력한다.

- M N 지점까지 이동하지 못한경우 -1 출력

- visited[z][x][y] : z 가 0인경우, 벽을 아직 부수지 않았다. , z가 1인경우 벽을 이미 한번 부쉈다.

import Foundation

// 입력
let input = readLine()!.split(separator: " ").map{ Int($0)! }
var arr = [[Int]]()
for i in 0..<input[0] {
    let a = Array(readLine()!).map{ Int(String($0))! }
    arr.append(a)
}

// 최단경로를 기록할 visited 배열과 BFS를 이용할 needVistedQueue 배열
var visited = Array(repeating: Array(repeating: Array(repeating: 0, count: input[1]), count: input[0]), count: 2)
var needVisitQueue = [(x: Int, y: Int, z: Int)]()

// 상하좌우 방향
let dx = [0,1,0,-1]
let dy = [1,0,-1,0]

// 결과 변수
var result = Int.max

// 출발지점 설정과 출발지점도 최단경로에 세므로 1로 초기화
needVisitQueue.append((x: 0, y: 0, z: 0))
visited[0][0][0] = 1


// BFS
var idx = 0
while idx < needVisitQueue.count {
    var loc = needVisitQueue[idx]
    idx += 1
    
    // 목표지점에 도착한 경우 최단경로 갱신
    if loc.x == input[0] - 1 && loc.y == input[1] - 1 {
        if result > visited[loc.z][loc.x][loc.y] && visited[loc.z][loc.x][loc.y] != 0 {
            result = visited[loc.z][loc.x][loc.y]
        }
        continue
    }
    for i in 0..<4 {
        let mx = dx[i] + loc.x
        let my = dy[i] + loc.y
        let mz = loc.z

        if mx >= 0 && mx < input[0] && my >= 0 && my < input[1] {
            // 다음 위치로 이동 할 수 있고, 아직 방문하지않은곳이라면
            if arr[mx][my] == 0 && visited[mz][mx][my] == 0 {
                visited[mz][mx][my] = visited[loc.z][loc.x][loc.y] + 1
                needVisitQueue.append((x: mx, y: my, z: mz))
            }
            // 다음 위치가 벽이고 아직 부수지 않았다면
            if arr[mx][my] == 1 && mz == 0 {
                visited[mz+1][mx][my] = visited[loc.z][loc.x][loc.y] + 1
                needVisitQueue.append((x: mx, y: my, z: mz + 1))
            }
        }
    }
}

if result == Int.max {
    print(-1)
} else {
    print(result)
}

내가 푼 풀이

- 스네이크버드는 자신의 길이보다 작거나 같은 높이의 과일을 먹을 수 있으므로 높이가 가장 낮은 과일부터 먹는다.

- 높이가 가장 낮은곳에 있는 과일부터 먹으며 과일을 못먹는경우 늘어난 길이 출력 , 다먹어도 출력

import Foundation

// 입력
let input = readLine()!.split(separator: " ").map{ Int($0)! }
var fruits = readLine()!.split(separator: " ").map{ Int($0)! }
var len = input[1]

// 과일의 높이가 담긴 배열 내림차순 정렬
fruits.sort{ $0 > $1 }

// 과일먹기
// 해당높이가 스네이크버드의 길이보다 작거나 같으면 먹고 길이가 자란다.
while !fruits.isEmpty {
    let food = fruits.removeLast()
    if len >= food {
        len += 1
    } else {
        break
    }
}
print(len)

import Foundation

// 입력
let input = Int(readLine()!)!
var arr = readLine()!.split(separator: " ").map{ Int($0)! }

// r: 결과배열, dp: 가장 긴 부분수열을 저장할 배열
var r = [Int]()
var dp = Array(repeating: [Int](), count: input)

// 수열의 각 원소는 최소 자신만 갖는 부분수열로 길이가 1이다.
// 현재원소가 이전원소보다 크다면 이전원소의 dp에 저장된 배열 + 현재원소를 저장하여 최신화
for i in 0..<arr.count {
    dp[i] = [arr[i]]
    for j in 0..<i {
        if arr[i] > arr[j] {
            var a = dp[j]
            a.append(arr[i])
            if a.count > dp[i].count {
                dp[i] = a
            }
        }
    }
    // 가장 긴 부분수열 최신화
    if dp[i].count > r.count {
        r = dp[i]
    }
}

print(r.count)
print(r.map{String($0)}.joined(separator: " "))

내가 푼 풀이

- 주어진 문자열에서 U C P C 차례로 존재하면 I love UCPC 출력, 존재하지 않다면 I hate UCPC 출력한다.

- 이중반복문으로 탐색한다.

import Foundation

var str = ["U", "C", "P", "C"]
var arr = readLine()!.split(separator: " ").map{ String($0) }
var idx = 0

for i in arr {
    for j in i {
        let s = String(j)
        if idx < str.count && s == str[idx] {
            idx += 1
        }
    }
}

if idx == 4 {
    print("I love UCPC")
} else {
    print("I hate UCPC")
}

내가 푼 풀이

- 주어진 N * N 게임판과 같은 크기의 배열 dp를 선언한다.

- (0, 0) 에서 반드시 오른쪽, 아래로만 이동가능하고, 도착점은 (n-1, n-1) 지점이다.

- 이중 반복문은 1행 1열,2열,3열, ... , 2행 1열,2열3열, .... , n행 1열 순으로 순회하므로 이동은 항상 인덱스에서 더해지기 때문에

- 이동한 지점에 이전 dp값을 더하는 방식으로 풀었다.

- dp[i][j] = i행j열까지의 이동한 경로의 수

import Foundation

let n = Int(readLine()!)!
var arr = [[Int]]()
var dp = Array(repeating: Array(repeating: 0, count: n), count: n)

// 게임판 입력
for i in 0..<n {
    arr.append(readLine()!.split(separator: " ").map{ Int($0)! })
}
dp[0][0] = 1

// DP
// 이동한지점은 이전지점의 DP값을 더해가는 방식을 사용
for i in 0..<n {
    for j in 0..<n {
        if dp[i][j] != 0 && arr[i][j] != 0 {
            let m = arr[i][j]
            if i+m < n {
                dp[i+m][j] += dp[i][j]
            }
            if j+m < n {
                dp[i][j+m] += dp[i][j]
            }
        }
    }
}

print(dp[n-1][n-1])

문제

체스판 위에 한 나이트가 놓여져 있다. 나이트가 한 번에 이동할 수 있는 칸은 아래 그림에 나와있다. 나이트가 이동하려고 하는 칸이 주어진다. 나이트는 몇 번 움직이면 이 칸으로 이동할 수 있을까?

내가 푼 풀이

- 주어진 체스판에서 시작점부터 BFS 탐색으로 이동한 곳에 +1 카운트를 해준다.

- 따로 카운트해줄 배열 dp를 선언해 저장하고, 도착점이 목적지랑 같은경우 탐색 종료해준다.

import Foundation

let c = Int(readLine()!)!

// 나이트의 이동
var dx = [1, 2, -1, -2, 1, 2, -1, -2]
var dy = [2, 1, -2, -1, -2, -1, 2, 1]

for i in 0..<c {
    var len = Int(readLine()!)!
    var board = Array(repeating: Array(repeating: 0, count: len), count: len)
    var dp = Array(repeating: Array(repeating: 0, count: len), count: len)
    var s = readLine()!.split(separator: " ").map{ Int($0)! }
    var d = readLine()!.split(separator: " ").map{ Int($0)! }
    
    var needVisitQueue = [(x: s[0], y: s[1])]
    
    // BFS
    // 나이트를 움직일때 도착점이 탐색하지 않은곳이라면 +1 카운트
    // 이미 도착했던곳이라면 스킵한다.
    while !needVisitQueue.isEmpty {
        var loc = needVisitQueue.removeFirst()
        if loc.x == d[0] && loc.y == d[1] { break }
        
        for i in 0..<8 {
            var mx = loc.x + dx[i]
            var my = loc.y + dy[i]
            
            if (mx >= 0 && mx < len) && (my >= 0 && my < len) && (dp[mx][my] == 0){
                dp[mx][my] = dp[loc.x][loc.y] + 1
                needVisitQueue.append((x: mx, y: my))
            }
        }
    }
    print(dp[d[0]][d[1]])
}