Merge pull request #100 from wellFoundedDevelopers/jimin/23week

[이지민] 로봇 청소기, 보물섬, 센서, 합분해

src/main/kotlin/jimin/23week/로봇 청소기.kt

@@ -0,0 +1,64 @@
+package jimin.`23week`
+
+/*
+<문제>
+[로봇 청소기](https://www.acmicpc.net/problem/14503)
+
+<구현 방법>
+동서남북을 시계 반시계 방향으로 돌면서 빈칸이 있는 경우 해당 방향으로 전진하면서 dfs를 했다.
+이때 빈칸이 없으면 바라보는 방향의 반대 방향으로 후진해 재귀를 돌았다.
+
+<트러블 슈팅>
+*/
+
+class `이지민_로봇 청소기` {
+    var n = 0
+    var m = 0
+    lateinit var rooms: MutableList<MutableList<Int>>
+    val dx = mutableListOf(-1, 0, 1, 0)
+    val dy = mutableListOf(0, 1, 0, -1)
+    var result = 1
+
+    fun solve() {
+        readln().split(" ").map { it.toInt() }.apply {
+            n = first()
+            m = last()
+        }
+        var (x, y, d) = readln().split(" ").map { it.toInt() }
+        x += 1
+        y += 1
+        rooms = MutableList(n + 2) { MutableList(m + 2) { 1 } }
+        for (i in 0 until n) {
+            readln().split(" ").map { it.toInt() }.forEachIndexed { j, it ->
+                rooms[i + 1][j + 1] = it
+            }
+        }
+        dfs(x, y, d)
+        println(result)
+    }
+
+    fun dfs(x: Int, y: Int, d: Int) {
+        rooms[x][y] = -1
+        var direction = -1
+        for (i in 3 downTo 0) {
+            if (rooms[x + dx[(d + i) % 4]][y + dy[(d + i) % 4 % 4]] == 0) {
+                direction = (d + i) % 4
+                break
+            }
+        }
+        if (direction == -1) {
+            if (rooms[x + dx[(d + 2) % 4]][y + dy[(d + 2) % 4]] == -1) {
+                dfs(x + dx[(d + 2) % 4], y + dy[(d + 2) % 4], d)
+            } else {
+                return
+            }
+        } else {
+            result += 1
+            dfs(x+ dx[direction], y + dy[direction], direction)
+        }
+    }
+}
+
+fun main() {
+    `이지민_로봇 청소기`().solve()
+}

src/main/kotlin/jimin/23week/보물섬.kt

@@ -0,0 +1,80 @@
+package jimin.`23week`
+
+/*
+<문제>
+[보물섬](https://www.acmicpc.net/problem/2589)
+
+<구현 방법>
+bfs를 응용하였다.
+현재 queue에 있는 것을 모두 꺼내서 갈 수 있는 영역을 subQueue에 담고,
+queue를 clear 시킨후 subQueue의 내용을 queue에 담아 dfs를 구현했다.
+
+<트러블 슈팅>
+ */
+
+import java.lang.Integer.*
+
+class 이지민_보물섬 {
+    lateinit var map: MutableList<MutableList<String>>
+    val dx = mutableListOf(0, 0, 1, -1)
+    val dy = mutableListOf(1, -1, 0, 0)
+    var result = 0
+
+    fun solve() {
+        val (n, m) = readln().split(" ").map { it.toInt() }
+        map = MutableList(n + 2) { MutableList(m + 2) { "W" } }
+        for (i in 0 until n) {
+            readln().chunked(1).forEachIndexed { j, it ->
+                map[i + 1][j + 1] = it
+            }
+        }
+
+        for (i in 1..n) {
+            for (j in 1..m) {
+                if (map[i][j] == "L") {
+                    result = max(result, bfs(map.deepCopy(), i, j))
+
+                }
+            }
+        }
+
+        println(result)
+
+    }
+
+    fun bfs(map: MutableList<MutableList<String>>, x: Int, y: Int): Int {
+        var queue = mutableListOf(Pair(x, y))
+        var sum = - 1
+        map[x][y] = "W"
+
+        while(queue.isNotEmpty()) {
+            val subQueue = mutableListOf<Pair<Int, Int>>()
+            queue.forEach{ num ->
+                for (i in 0 until 4) {
+                    if(map[num.first + dx[i]][num.second + dy[i]] == "L") {
+                        subQueue.add(Pair(num.first + dx[i], num.second + dy[i]))
+                        map[num.first + dx[i]][num.second + dy[i]] = "W"
+                    }
+                }
+            }
+            queue.clear()
+            queue = subQueue.toMutableList()
+            subQueue.clear()
+
+            sum += 1
+        }
+        return sum
+    }
+
+    private fun MutableList<MutableList<String>>.deepCopy(): MutableList<MutableList<String>> {
+        val new = mutableListOf<MutableList<String>>()
+        this.forEach {
+            new.add(it.toMutableList())
+        }
+        return new
+    }
+}
+
+fun main() {
+    이지민_보물섬().solve()
+}

src/main/kotlin/jimin/23week/센서.kt

@@ -0,0 +1,52 @@
+package jimin.`23week`
+
+/*
+<문제>
+[센서](https://www.acmicpc.net/problem/2212)
+
+<구현 방법>
+센서들 간의 거리와 해당 index를 가지는 distance 리스트를 만들었다.
+이를 센서들 간의 거리를 기준으로 내림차순으로 정렬하고 k - 1 개만큼 sublist를 만들고 나서,
+마지막 부분도 들어가야하니 추가하고 난 뒤 다시 index를 기준으로 오름차순 정렬한 distance 리스트를 구했다.
+이를 for문으로 돌면서 센서간의 차이를 result에 더하여 출력했다.
+
+<트러블 슈팅>
+처음에 문제를 잘못이해해서 삽질했다..
+k가 n 이상일 때는 런타임 에러가 난다! 이 경우 바로 0을 출력하게 하였다.
+ */
+
+class 센서 {
+    fun solve() {
+        val n = readln().toInt()
+        val k = readln().toInt()
+        val sensors = readln().split(" ").map { it.toInt() }.sorted()
+        var distances = mutableListOf<Pair<Int, Int>>()
+
+        if (n <= k) {
+            println(0)
+            return
+        }
+
+        for(i in 1 until n) {
+            distances.add(Pair(i - 1, sensors[i] - sensors[i - 1]))
+        }
+        distances.sortByDescending { it.second }
+        distances = (distances.subList(0, k - 1) + mutableListOf(Pair(n - 1, 0))) as MutableList
+        distances.sortBy{ it.first }
+        var result = 0
+
+        distances.forEachIndexed{ idx, d ->
+            result += if (idx == 0) {
+                sensors[d.first] - sensors[0]
+            } else {
+                sensors[d.first] - sensors[distances[idx - 1].first + 1]
+            }
+        }
+
+        println(result)
+    }
+}
+
+fun main() {
+    센서().solve()
+}

src/main/kotlin/jimin/23week/합분해.kt

@@ -0,0 +1,36 @@
+package jimin.`23week`
+
+/*
+<문제>
+[합분해](https://www.acmicpc.net/problem/2225)
+
+<구현 방법>
+n은 n - m에 m을 더한 것이다.
+이 m은 0 ~ n까지 이다.
+DP[K][N] = DP[K-1][0] + DP[K-1][1] + ... + DP[K-1][N]
+
+<트러블 슈팅>
+오늘도 구글링..^^ https://hongjw1938.tistory.com/63
+*/
+
+class 합분해 {
+    fun solve() {
+        val (n, k) = readln().split(" ").map{ it.toInt() }
+        val dp = MutableList(k + 1){ MutableList(n + 1) { 0 } }
+        dp[1] = MutableList(n + 1) { 1 }
+
+        for(i in 2 .. k) {
+            for(j in 0 .. n) {
+                for (k in 0 .. j) {
+                    dp[i][j] += dp[i - 1][k]
+                    dp[i][j] %= 1_000_000_000
+                }
+            }
+        }
+        println(dp.last().last())
+    }
+}
+
+fun main() {
+    합분해().solve()
+}