[장희직] - 겹치는 건 싫어, 쉬운 최단거리, 회전 초밥, 기타리스트

src/main/kotlin/heejik/43week/겹치는 건 싫어.kt

@@ -0,0 +1,50 @@
+package heejik.`43week`
+
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.io.StreamTokenizer
+import kotlin.math.max
+import kotlin.properties.Delegates
+
+class `겹치는 건 싫어` {
+    var n by Delegates.notNull<Int>()
+    var k by Delegates.notNull<Int>()
+    lateinit var numbers: List<Int>
+    fun setting() = with(BufferedReader(InputStreamReader(System.`in`))) {
+        readLine().split(' ').map { it.toInt() }.run {
+            n = this[0]
+            k = this[1]
+        }
+        numbers = readLine().split(' ').map { it.toInt() }
+    }
+
+
+    fun solve() {
+        setting()
+
+        var answer = 0
+        val stored = ArrayDeque<Int>()
+        val counts = MutableList(100001) { 0 }
+
+        for (number in numbers) {
+            val numberCount = counts[number]
+            if (numberCount == k) {
+                answer = max(answer, stored.size)
+                while (true) {
+                    val removeNumber = stored.removeFirst()
+                    counts[removeNumber]--
+                    if (removeNumber == number) break
+                }
+            }
+            stored.add(number)
+            counts[number]++
+        }
+        answer = max(answer, stored.size)
+
+        println(answer)
+    }
+}
+
+fun main() {
+    `겹치는 건 싫어`().solve()
+}

src/main/kotlin/heejik/43week/기타리스트.kt

@@ -0,0 +1,52 @@
+package heejik.`43week`
+
+import kotlin.math.max
+import kotlin.properties.Delegates
+
+class 기타리스트 {
+
+    lateinit var differences: MutableList<Int>
+    lateinit var dp: MutableList<MutableList<Boolean>>
+    var n by Delegates.notNull<Int>()
+    var s by Delegates.notNull<Int>()
+    var m by Delegates.notNull<Int>()
+    var answer = -1
+
+    fun solve() {
+        readln().split(' ').map { it.toInt() }.run {
+            n = this[0]
+            s = this[1]
+            m = this[2]
+        }
+        differences = readln().split(' ').map { it.toInt() }.toMutableList()
+        dp = MutableList(n + 1) { MutableList(m + 1) { false } }
+        dp[0][s] = true
+
+        play().also {
+            println(it)
+        }
+    }
+
+    private fun play(): Int {
+        repeat(n) first@{ songIdx ->
+            repeat(m + 1) second@{ volume ->
+                if (dp[songIdx][volume].not()) return@second
+                val plusDiff = volume + differences[songIdx]
+                val minusDiff = volume - differences[songIdx]
+
+                if (plusDiff in 0..m) {
+                    dp[songIdx + 1][plusDiff] = true
+                }
+                if (minusDiff in 0..m) {
+                    dp[songIdx + 1][minusDiff] = true
+                }
+            }
+        }
+
+        return dp[n].lastIndexOf(true)
+    }
+}
+
+fun main() {
+    기타리스트().solve()
+}

src/main/kotlin/heejik/43week/쉬운 최단거리.kt

@@ -0,0 +1,74 @@
+package heejik.`43week`
+
+import kotlin.properties.Delegates
+
+class `쉬운 최단거리` {
+
+    val dx = listOf(1, -1, 0, 0)
+    val dy = listOf(0, 0, 1, -1)
+
+    data class Pos(
+        val x: Int,
+        val y: Int
+    )
+
+    lateinit var target: Pos
+    var n by Delegates.notNull<Int>()
+    var m by Delegates.notNull<Int>()
+    val board = mutableListOf<MutableList<Int>>()
+
+    fun solve() = with(System.`in`.bufferedReader()) {
+
+        readLine().split(' ').map { it.toInt() }.run {
+            n = this[0]
+            m = this[1]
+        }
+
+        repeat(n) {
+            val row = readLine().split(' ').map {
+                if (it == "1") -1
+                else it.toInt()
+            }
+            if (row.contains(2)) {
+                target = Pos(x = it, y = row.indexOf(2))
+            }
+            board.add(row.toMutableList())
+        }
+
+        bfs(target.x, target.y)
+
+        val sb = StringBuilder()
+        repeat(n) { x ->
+            repeat(m) { y ->
+                sb.append("${board[x][y]} ")
+            }
+            sb.appendLine()
+        }
+
+        print(sb)
+    }
+
+    private fun bfs(_x: Int, _y: Int) {
+        val queue = ArrayDeque<Pos>()
+        queue.add(Pos(_x, _y))
+        board[_x][_y] = 0
+
+        while (queue.isNotEmpty()) {
+            val (x, y) = queue.removeFirst()
+            for (i in dx.indices) {
+                val nx = x + dx[i]
+                val ny = y + dy[i]
+                if (nx in 0 until n && ny in 0 until m) {
+                    if (board[nx][ny] == -1) {
+                        queue.add(Pos(nx, ny))
+                        board[nx][ny] = board[x][y] + 1
+                    }
+                }
+            }
+        }
+    }
+}
+
+fun main() {
+    `쉬운 최단거리`().solve()
+}

src/main/kotlin/heejik/43week/회전 초밥.kt

@@ -0,0 +1,39 @@
+package heejik.`43week`
+
+import kotlin.math.max
+
+class `회전 초밥` {
+
+    fun solve() = with(System.`in`.bufferedReader()) {
+        var answer = 0
+
+        val belt = mutableListOf<Int>()
+
+        val (n, d, k, c) = readLine().split(' ').map { it.toInt() }
+
+        repeat(n) {
+            val sushi = readLine().toInt()
+            belt.add(sushi)
+        }
+        // 맨 뒤에 k - 1 만큼 앞에 놈들 추가
+        repeat(k - 1) {
+            belt.add(belt[it])
+        }
+
+        repeat(n) { i ->
+            val partBeltSet = belt.subList(i, i + k).toSet()
+            answer = if (partBeltSet.contains(c)) {
+                max(answer, partBeltSet.size)
+            } else {
+                max(answer, partBeltSet.size + 1)
+            }
+        }
+
+        println(answer)
+    }
+}
+
+
+fun main() {
+    `회전 초밥`().solve()
+}