Jenikeju

내가 푼 풀이

- 주어진 그래프를 연결리스트로 저장한다.

- DFS를 이용하여 시작점부터 이동할 수 있는 모든 정점을 탐색하고 저장한다.

- 0번째부터 n-1번째까지 반복하며 탐색한다.

- 이미 방문한 지점이라면 break를 통해 반복문을 탈출했었지만, 만약 이중으로 연결된 리스트라면 break 반복탈출은 원하는 답이 안 나온다.

- 주어진 정점의 개수가 작아서 모든 간선을 탐색하는 방법을 사용했다.

import Foundation

// 입력
let n = Int(readLine()!)!
var graph = [Int: [Int]]()

// 그래프 입력
for i in 0..<n {
    let input = readLine()!.split(separator: " ").map{ Int($0)! }
    for j in 0..<input.count {
        if input[j] == 1 {
            if graph[i] == nil {
                graph[i] = [j]
            } else {
                graph[i]!.append(j)
            }
        }
    }
}

// DFS
for i in 0..<n {
    var arr = Array(repeating: 0, count: n)
    var needVisitQueue = [Int]()
    if graph[i] != nil {
        needVisitQueue = graph[i]!
        while !needVisitQueue.isEmpty {
            var node = needVisitQueue.removeLast()
            if arr[node] == 1 { continue }
            
            arr[node] = 1
            if graph[node] != nil {
                needVisitQueue += graph[node]!
            }
        }
    }
    print(arr.map{ String($0) }.joined(separator: " "))
}

내가 푼 풀이

- 후보의 수를 다득표순으로 정렬했을때, 첫번째 원소가 다솜보다 작을때 까지 매수하면된다.

- 매수한 만큼의 수를 출력

import Foundation

// 입력
var N = Int(readLine()!)!
var arr = [Int]()
var cnt = 0

// 후보 입력
for i in 0..<N {
    arr.append(Int(readLine()!)!)
}

// 다솜
var ds = arr[0]
arr.removeFirst()
arr.sort { $0 > $1 }

// 후보를 다득표순으로 정렬후, 맨 첫번째 원소가 다솜보다 작을때까지 매수한다.
while !arr.isEmpty && arr[0] >= ds {
    cnt += 1
    ds += 1
    arr[0] -= 1
    arr.sort { $0 > $1 }
}

print(cnt)

내가 푼 풀이

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

- 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")
}