[Week4] 소병희: 근손실, 회의실 배정, 트리의 부모 찾기, 지름길

src/3week/byeonghee/단풍잎 이야기.kt

@@ -0,0 +1,66 @@
+package `3week`.byeonghee
+
+import java.io.*
+
+class `소병희_단풍잎 이야기` {
+    companion object {
+        fun getSolution() : Solution {
+            return Solution()
+        }
+    }
+
+    class Solution {
+        val br = BufferedReader(InputStreamReader(System.`in`))
+
+        var n = 0
+        var m = 0
+
+        val games = mutableListOf<Int>()
+        val useList = mutableSetOf<Int>()
+        val pickList = mutableSetOf<Int>()
+        var answer = 0
+
+        fun getBit(n: Int) : Int {
+            return 1 shl n
+        }
+
+        fun dfs(bm: Int, pick: Int) {
+            if (pick == n) {
+                pickList.add(bm)
+                return
+            }
+
+            for(i in useList) {
+                if (getBit(i) and bm > 0) continue
+                dfs(bm + getBit(i), pick + 1)
+            }
+        }
+
+
+        fun solution() {
+            br.readLine().split(" ").map{ it.toInt() }.let {
+                n = it[0]
+                m = it[1]
+            }
+
+            repeat(m) {
+                br.readLine().split(" ")
+                    .fold(0) { acc, v ->
+                        useList.add(v.toInt())
+                        acc + getBit(v.toInt())
+                    }
+                    .let { games.add(it) }
+            }
+
+            dfs(0, 0)
+
+            pickList.forEach { bm -> answer = Integer.max(answer, games.count { it and bm == it }) }
+
+            println(answer)
+        }
+    }
+}
+
+fun main() {
+    `소병희_단풍잎 이야기`.getSolution().solution()
+}

src/3week/byeonghee/도피.kt

@@ -0,0 +1,74 @@
+package `3week`.byeonghee
+
+import java.io.*
+
+class `소병희_도피` {
+    companion object {
+        fun getSolution() : Solution {
+            return Solution()
+        }
+    }
+
+    class Solution {
+        companion object {
+            const val ONEPROB = 1000000000000000000L
+        }
+
+        val br = BufferedReader(InputStreamReader(System.`in`))
+
+        var n = 0
+
+        var dp = Array(0) { LongArray(0) }
+        var moves = Array(0) { LongArray(0) }
+        var ans = 0L
+        var cityList = mutableListOf<Int>()
+
+        fun getDp(day: Int, dst: Int) {
+            if (dp[day][dst] > -1) return
+
+            var prob = 0L
+            for(from in 0 until n) {
+                if(dp[day-1][from] < 0) getDp(day-1, from)
+                prob += dp[day-1][from] * moves[from][dst]
+            }
+            dp[day][dst] = prob
+        }
+
+        fun solution() {
+
+            val (n_tmp, m) = br.readLine().split(" ").map{ it.toInt() }
+            n = n_tmp
+
+            dp = Array(9) { LongArray(n){ -1 } }
+            moves = Array(n) { LongArray(n) }
+
+            repeat(m) {
+                br.readLine().split(" ").map{ it.toInt() }.let {
+                    moves[it[0]][it[1]] = it[2].toLong()
+                }
+            }
+
+            dp[0].fill(0)
+            moves[0].forEachIndexed { i, v -> dp[0][i] = v }
+
+            for(e in 0 until n) {
+                getDp(8, e)
+                if (ans < dp[8][e]) {
+                    ans = dp[8][e]
+                    cityList = mutableListOf(e)
+                }
+                else if (ans == dp[8][e]) {
+                    cityList.add(e)
+                }
+            }
+
+            println(cityList.joinToString(" "))
+            if (ans == ONEPROB) println("1." + "0".repeat(18))
+            else println(String.format("0.%18d", ans))
+        }
+    }
+}
+
+fun main() {
+    `소병희_도피`.getSolution().solution()
+}

src/3week/byeonghee/랜선 자르기.kt

@@ -0,0 +1,58 @@
+package `3week`.byeonghee
+
+import java.io.*
+
+/**
+ * 1. Key: 자르는 길이, value: 만들 수 있는 랜선 개수 를 쌍으로 가지는 맵을 아예 만들었었다
+ * 2. key가 1부터 2^31 - 1까지 갈 수 있기 때문에 이진탐색을 하면서 key에 대해 value를 계산하는 것이 빠름
+ * 3. 2로 바꾸고 나니 key가 int일 필요 없어서 lb, ub, maxLength, mid를 전부 long타입으로 수정
+ * 4. 마찬가지로 2로 바꾸고 나니 maxLength가 큰 수여도 괜찮아져서 그냥 제일 긴 랜선 값 할당
+ */
+
+class `소병희_랜선 자르기` {
+    companion object {
+        fun getSolution(): Solution {
+            return Solution()
+        }
+    }
+
+    class Solution {
+        val br = BufferedReader(InputStreamReader(System.`in`,))
+
+        var maxLength = 0L
+        var lans = IntArray(0)
+//      var searchMap = mapOf<Int, Int>()
+
+        var lb = 1L
+        var ub = 1L
+        var mid = 1L
+
+        fun solution() {
+            val (k, n) = br.readLine().split(" ").map { it.toInt() }
+            lans = IntArray(k) { br.readLine().toInt() }
+
+            maxLength = lans.maxOf { it }.toLong()
+            //maxLength = Integer.max(lans.minOf { it }, (lans.sumOf { it.toLong() } / n).toInt())
+            //searchMap = (1..maxLength).toList().map { len -> len to lans.sumOf { it / len } }.toMap()
+
+            println(bisearch(n))
+        }
+
+        fun bisearch(n: Int): Int {
+            lb = 1
+            ub = maxLength + 1
+
+            while(lb + 1 < ub) {
+                mid = lb + ((ub - lb) / 2)
+                if(lans.sumOf { it / mid.toInt() } >= n) lb = mid
+                else ub = mid
+            }
+
+            return lb.toInt()
+        }
+    }
+}
+
+fun main() {
+    `소병희_랜선 자르기`.getSolution().solution()
+}

src/3week/byeonghee/마법사 상어와 복제.kt

@@ -0,0 +1,149 @@
+package `3week`.byeonghee
+
+import java.io.*
+
+val br = BufferedReader(InputStreamReader(System.`in`))
+
+var m = 0
+var s = 0
+var r = 0
+var c = 0
+var d = 0
+
+data class Pos(var r: Int, var c: Int) {
+    operator fun plus(add: Pos): Pos {
+        return Pos(r + add.r, c + add.c)
+    }
+
+    fun isIn(): Boolean {
+        return r in 0 until 4 && c in 0 until 4
+    }
+
+    fun flatIdx() : Int {
+        return r * 4 + c
+    }
+}
+data class Fish(var p: Pos, var d: Int)
+
+val di = arrayOf(
+    Pos(1, -1),
+    Pos(1, 0), //하
+    Pos(1, 1),
+    Pos(0, 1), //우
+    Pos(-1, 1),
+    Pos(-1, 0), //상
+    Pos(-1, -1),
+    Pos(0, -1) //좌
+)
+
+var prevFishCnt = 0
+var curFishCnt = 0
+val prevGrid = IntArray(16) //flatten
+val smells = IntArray(16)
+val curGrid = IntArray(16)
+val fishs = ArrayDeque<Fish>()
+var shark = Pos(0, 0)
+val sharkMv = Array(64) { Array(3) { Pos(0, 0) }}
+lateinit var newFish: Fish
+var canGo = true
+
+
+fun main() {
+    br.readLine().split(" ").map { it.toInt() }.let {
+        m = it[0]
+        s = it[1]
+    }
+
+    repeat(m) {
+        br.readLine().split(" ").map { it.toInt() }.let {
+            fishs.addLast(Fish(Pos(it[0]-1, it[1]-1), 8 - it[2]))
+            prevGrid[Pos(it[0]-1, it[1]-1).flatIdx()]++
+        }
+    }
+
+    br.readLine().split(" ").map { it.toInt() }.let {
+        shark.r = it[0] - 1
+        shark.c = it[1] - 1
+    }
+
+    val dPriority = listOf(5, 7, 1, 3)
+    var cnt = 0
+
+    for(f in dPriority) for(s in dPriority) for (t in dPriority) {
+        sharkMv[cnt++] = arrayOf(di[f], di[f] + di[s], di[f] + di[s] + di[t])
+    }
+
+
+    var maxCnt = -1
+    var tmpCnt: Int
+    var maxMv = -1
+
+    for(t in 0 until s) {
+        // 1, 2번 같이 수행
+        prevFishCnt = curFishCnt
+        curFishCnt = fishs.size
+        for(i in 0 until fishs.size) {
+            while (i >= prevFishCnt && smells[fishs[i].p.flatIdx()] == 2) {
+                fishs.removeAt(i)
+                curFishCnt--
+                if (i == fishs.size) break
+            }
+            newFish = fishs[i].copy()
+            canGo = true
+            while((newFish.p + di[newFish.d]).isIn().not()
+                || smells[(newFish.p + di[newFish.d]).flatIdx()] > 0
+                || shark == (newFish.p + di[newFish.d])) {
+                newFish.d = (newFish.d + 1) % 8
+                if (newFish.d == fishs[i].d) {
+                    canGo = false
+                    break
+                }
+            }
+            if(canGo) newFish.p += di[newFish.d]
+            fishs.add(newFish)
+            curGrid[newFish.p.flatIdx()]++
+        }
+
+        //3-1. 상어 이동순서 구하기
+        maxCnt = -1
+        maxMv = -1
+        for(mv in sharkMv.indices) {
+            if (sharkMv[mv].any { (shark + it).isIn().not() }) continue
+
+            sharkMv[mv].let {
+                tmpCnt = curGrid[(it[0] + shark).flatIdx()]
+                tmpCnt += curGrid[(it[1] + shark).flatIdx()]
+                if (it[2] != it[0]) {
+                    tmpCnt += curGrid[(it[2] + shark).flatIdx()]
+                }
+            }
+
+            if (tmpCnt > maxCnt) {
+                maxCnt = tmpCnt
+                maxMv = mv
+            }
+        }
+
+        //3-2. 상어 잡아먹기 + 냄새 흐려지기
+        for(i in 0 until 16) {
+            if (smells[i] > 0) smells[i]--
+            prevGrid[i] += curGrid[i]
+        }
+        sharkMv[maxMv].map{ (shark + it).flatIdx() }.forEach {
+            if (prevGrid[it] > 0) {
+                smells[it] += 2
+                prevGrid[it] -= curGrid[it]
+            }
+        }
+        shark += sharkMv[maxMv][2]
+        curGrid.fill(0)
+    }
+
+//    tmpCnt = 0
+//    for(i in 0 until 16) {
+//        if (smells[i] == 2) tmpCnt += prevGrid[i]
+//    }
+
+//    println(fishs.size - tmpCnt)
+    println(prevGrid.sumOf { it })
+}