[우석] 네크워트, 이중우선순위큐

최우석/네트워크.md

@@ -0,0 +1,41 @@
+# 네트워크
+
+```kotlin
+import java.util.*
+
+class Solution {
+    fun solution(n: Int, computers: Array<IntArray>): Int {
+        var answer = 0
+
+        var visited = Array(computers.size) { false }
+
+        for ((n, computer) in computers.withIndex()) {
+            if (visited[n]) {
+                continue
+            }
+            visited[n] = true
+            bfs(n, computers, visited)
+            answer += 1
+        }
+        return answer
+    }
+
+    fun bfs(n: Int, computers: Array<IntArray>, visited: Array<Boolean>) {
+        var queue: Queue<Int> = LinkedList<Int>()
+        queue.add(n)
+
+        while (queue.isNotEmpty()) {
+            var now = queue.poll()
+
+            for ((next, computer) in computers[now].withIndex()) {
+                if (visited[next] || computer != 1) {
+                    continue
+                }
+                queue.add(next)
+                visited[next] = true
+            }
+        }
+    }
+}
+
+```

최우석/이중우선순위큐.md

@@ -0,0 +1,63 @@
+# 이중우선순위큐
+
+```kotlin
+import java.util.*
+
+class Solution {
+    fun solution(operations: Array<String>): IntArray {
+        var answer = intArrayOf()
+
+        var totalQueue = mutableSetOf<Int>()
+        var minQueue = PriorityQueue<Int>()
+        var maxQueue = PriorityQueue<Int>(Collections.reverseOrder())
+
+        for (operation in operations) {
+            var (command, numberValue) = operation.split(" ")
+            val number = numberValue.toInt()
+
+            if (command == "I") {
+                totalQueue.add(number)
+                minQueue.add(number)
+                maxQueue.add(number)
+            } else if (command == "D") {
+                if (number == 1) {
+                    while (maxQueue.isNotEmpty()) {
+                        val maxNumber = maxQueue.poll()
+                        if (totalQueue.contains(maxNumber)) {
+                            totalQueue.remove(maxNumber)
+                            break
+                        }
+                    }
+                } else {
+                    while (minQueue.isNotEmpty()) {
+                        val minNumber = minQueue.poll()
+                        if (totalQueue.contains(minNumber)) {
+                            totalQueue.remove(minNumber)
+                            break
+                        }
+                    }
+                }
+            }    
+        }
+        print(totalQueue)
+        var maxNumber = 0
+        var minNumber = 0
+        while (maxQueue.isNotEmpty()) {
+            maxNumber = maxQueue.poll()
+            print(maxNumber)
+            if (totalQueue.contains(maxNumber)) {
+                break
+            }
+            maxNumber = 0
+        }
+        while (minQueue.isNotEmpty()) {
+            minNumber = minQueue.poll()
+            if (totalQueue.contains(minNumber)) {
+                break
+            }
+            minNumber = 0
+        }
+        return intArrayOf(maxNumber, minNumber)
+    }
+}
+```