Merge pull request #171 from wellFoundedDevelopers/hyunsoo/44week

[전현수] - 케빈 베이컨의 6단계 법칙, 함께 블록 쌓기, 전구와 스위치, CCW

src/main/kotlin/hyunsoo/44week/CCW.kt

@@ -0,0 +1,62 @@
+package hyunsoo.`44week`
+
+/**
+ *
+ * <문제>
+ * [CCW](https://www.acmicpc.net/problem/11758)
+ *
+ * - 아이디어
+ *
+ * [참고](https://velog.io/@jini_eun/%EB%B0%B1%EC%A4%80-11758%EB%B2%88-CCW-Java-Python)
+ *
+ * x1 x2 x3 x4
+ * y1 y2 y3 y4
+ * - 트러블 슈팅
+ *
+ */
+class `전현수_CCW` {
+
+    private data class Point(val x: Int, val y: Int)
+
+    fun solution() {
+        val p = Array(3) {
+            readln().split(" ")
+                .map { it.toInt() }
+                .run {
+                    Point(first(), last())
+                }
+        }
+
+        val first = (0..2).run {
+            var triangle = 0
+            this.forEach { index ->
+                triangle += p[index % 3].x * p[(index + 1) % 3].y
+            }
+            triangle
+        }
+
+        val second = (1..3).run {
+            var triangle = 0
+            this.forEach { index ->
+                triangle += p[index % 3].y * p[(index + 1) % 3].x
+            }
+            triangle
+        }
+
+        val answer = first - second
+        println(
+            if (0 < answer) {
+                1
+            } else if (answer < 0) {
+                -1
+            } else {
+                0
+            }
+        )
+
+    }
+}
+
+fun main() {
+    전현수_CCW().solution()
+}

src/main/kotlin/hyunsoo/44week/전구와 스위치.kt

@@ -0,0 +1,94 @@
+package hyunsoo.`44week`
+
+import kotlin.math.min
+
+/**
+ *
+ * <문제>
+ * [전구와 스위치](https://www.acmicpc.net/problem/2138)
+ *
+ * - 아이디어
+ *
+ * - 트러블 슈팅
+ *
+ */
+class `전현수_전구와_스위치` {
+
+    private var bulbCnt = 0
+
+    fun solution() {
+
+        bulbCnt = readln().toInt()
+
+        val currentState = readln().chunked(1)
+            .toTypedArray()
+
+        val targetState = readln().chunked(1)
+            .toTypedArray()
+
+
+        var firstCaseCnt = 0
+        val firstCase = currentState.toList().toTypedArray()
+        var secondCaseCnt = 1
+        val secondCase = currentState.toList().toTypedArray().apply {
+            this.singleSwitch(0)
+            this.singleSwitch(1)
+        }
+
+        for (index in 1 until bulbCnt) {
+            if (firstCase[index - 1] != targetState[index - 1]) {
+                firstCase.switch(index)
+                firstCaseCnt++
+            }
+            if (secondCase[index - 1] != targetState[index - 1]) {
+                secondCase.switch(index)
+                secondCaseCnt++
+            }
+        }
+
+        when {
+            firstCase.contentEquals(targetState) -> {
+                if (firstCase.contentEquals(secondCase)) {
+                    println(min(firstCaseCnt, secondCaseCnt))
+                } else {
+                    println(firstCaseCnt)
+                }
+            }
+
+            secondCase.contentEquals(targetState) -> {
+                if (firstCase.contentEquals(secondCase)) {
+                    println(min(firstCaseCnt, secondCaseCnt))
+                } else {
+                    println(secondCaseCnt)
+                }
+            }
+
+            else -> println(-1)
+        }
+
+
+    }
+
+    private fun Array<String>.switch(pos: Int) {
+        when (pos) {
+            bulbCnt - 1 -> {
+                this.singleSwitch(pos - 1)
+                this.singleSwitch(pos)
+            }
+
+            else -> {
+                this.singleSwitch(pos - 1)
+                this.singleSwitch(pos)
+                this.singleSwitch(pos + 1)
+            }
+        }
+    }
+
+    private fun Array<String>.singleSwitch(pos: Int) {
+        if (this[pos] == "0") this[pos] = "1" else this[pos] = "0"
+    }
+}
+
+fun main() {
+    전현수_전구와_스위치().solution()
+}

src/main/kotlin/hyunsoo/44week/케빈 베이컨의 6단계 법칙.kt

@@ -0,0 +1,86 @@
+package hyunsoo.`44week`
+
+import java.util.LinkedList
+import java.util.Queue
+
+/**
+ *
+ * <문제>
+ * [케빈 베이컨의 6단계 법칙](https://www.acmicpc.net/problem/1389)
+ *
+ * - 아이디어
+ *
+ * - 트러블 슈팅
+ *
+ */
+class `전현수_케빈_베이컨의_6단계_법칙` {
+
+    private lateinit var friendshipInfo: Array<BooleanArray>
+
+    fun solution() {
+
+        val (userCnt, relationCnt) = readln().split(" ").map { it.toInt() }
+
+        var minSum = Int.MAX_VALUE
+        var answer = 9999
+
+        friendshipInfo = Array(userCnt + 1) {
+            BooleanArray(userCnt + 1)
+        }
+
+        repeat(relationCnt) {
+            val (first, second) = readln().split(" ").map { it.toInt() }
+            friendshipInfo[first][second] = true
+            friendshipInfo[second][first] = true
+        }
+
+        for (i in 1..userCnt) {
+
+            val checkList = IntArray(userCnt + 1).apply {
+                this[0] = -1
+                this[i] = -1
+            }
+
+            val queue: Queue<Pair<Int, Int>> = LinkedList()
+
+            val initFriends = friendshipInfo[i]
+                .mapIndexed { index, isFriend ->
+                    if (isFriend) index else -1
+                }.filter { it != -1 }
+
+            initFriends.forEach { friendIndex ->
+                queue.add(friendIndex to 1)
+                checkList[friendIndex] = 1
+            }
+
+            while (queue.isNotEmpty()) {
+                val (friendIndex, distance) = queue.poll()
+
+                val friends = friendshipInfo[friendIndex]
+                    .mapIndexed { index, isFriend ->
+                        if (isFriend && index != i) index else -1
+                    }.filter { it != -1 }
+
+                friends.forEach { friendIndex ->
+                    if (checkList[friendIndex] == -1 ||
+                        checkList[friendIndex] != 0
+                    ) return@forEach
+                    queue.add(friendIndex to distance + 1)
+                    checkList[friendIndex] = distance + 1
+                }
+
+            }
+            val currentBaconNumSum = checkList.sumOf { it } + 2
+            if (currentBaconNumSum < minSum) {
+                answer = i
+                minSum = currentBaconNumSum
+            }
+        }
+
+        println(answer)
+    }
+}
+
+fun main() {
+    전현수_케빈_베이컨의_6단계_법칙().solution()
+}

src/main/kotlin/hyunsoo/44week/함께 블록 쌓기.kt

@@ -0,0 +1,57 @@
+package hyunsoo.`44week`
+
+/**
+ *
+ * <문제>
+ * [함께 블록 쌓기](https://www.acmicpc.net/problem/18427)
+ *
+ * - 아이디어
+ *
+ * - 트러블 슈팅
+ *
+ */
+class `전현수_함께_블록_쌓기` {
+
+    fun solution() {
+
+        val (studentCnt, maxBlock, targetHeight) = readln().split(" ").map { it.toInt() }
+
+        val studentInfo = Array(studentCnt + 1) {
+            mutableListOf<Int>()
+        }
+
+        repeat(studentCnt) { index ->
+            readln().split(" ")
+                .map { it.toInt() }
+                .forEach { height ->
+                    studentInfo[index + 1].add(height)
+                }
+        }
+
+        val dp = Array(studentCnt + 1) {
+            IntArray(targetHeight + 1).apply {
+                this[0] = 1
+            }
+        }
+
+        for (i in 1..studentCnt) {
+            for (j in 1..targetHeight) {
+                dp[i][j] += dp[i - 1][j]
+                dp[i][j] %= 10007
+
+                studentInfo[i].forEach { blockHeight ->
+                    val target = j - blockHeight
+                    if (target < 0) return@forEach
+                    dp[i][j] += dp[i - 1][target]
+                    dp[i][j] %= 10007
+                }
+            }
+        }
+
+        println(dp[studentCnt][targetHeight] % 10007)
+    }
+}
+
+fun main() {
+    전현수_함께_블록_쌓기().solution()
+}