[Week4] 안찬우: 근손실, 회의실 배정, 트리의 부모 찾기, 주차 요금 계산, 지름길

src/4week/acw/근손실.kt

@@ -0,0 +1,54 @@
+package `4week`.acw
+
+class `acw근손실` {
+    lateinit var exerciseKits: List<Int>
+    lateinit var visit: Array<Boolean>
+    var cnt = 0
+
+
+    fun makePermutation(arr: MutableList<Int>, power: Int, day: Int, N: Int, K: Int) {
+        //순열구성하기
+        var powerNow = power
+        if (arr.isNotEmpty()) {
+            powerNow = power + arr.last() - K
+        }
+
+        if (powerNow < 500) {
+            return
+        }
+
+        if (day == N) {
+            cnt++
+            return
+        }
+
+        for (i in 0 until N) {
+            if (visit[i]) {
+                continue
+            }
+
+            arr.add(exerciseKits[i])
+            visit[i] = true
+            makePermutation(arr, powerNow, day + 1, N, K)
+            arr.remove(exerciseKits[i])
+            visit[i] = false
+        }
+    }
+
+
+    fun solution() {
+        val (N, K) = readln().split(" ").map { it.toInt() }
+        exerciseKits = readln().split(" ").map { it.toInt() }
+        visit = Array(N) { false }
+        makePermutation(mutableListOf(), 500, 0, N, K)
+
+        println(cnt)
+
+    }
+}
+
+fun main() {
+    val sol = `acw근손실`()
+    sol.solution()
+}
+

src/4week/acw/주차요금계산.kt

@@ -0,0 +1,71 @@
+import java.util.LinkedList
+
+class Solution {
+
+    val recordsArr = Array(10000) { LinkedList<String>() }
+    val feeArr = Array(10000) { 0 }
+
+    fun solution(fees: IntArray, records: Array<String>): IntArray {
+        var answer: IntArray = intArrayOf()
+        for (i in records) {
+            val (time, num, inout) = i.split(" ")
+            if (inout == "IN") {
+                recordsArr[num.toInt()].add(time)
+            } else {
+                //out이 나올경우에는 바로 해당번호에 대해 처리를 해준다.
+                val inTime = recordsArr[num.toInt()].removeLast()
+
+                val inHM = inTime.split(":").map { it.toInt() }
+                val outHM = time.split(":").map { it.toInt() }
+
+                val usingTime = outHM[0] * 60 + outHM[1] - inHM[0] * 60 - inHM[1]
+                feeArr[num.toInt()] += usingTime
+            }
+        }
+
+        for (i in 0 until 10000) {
+            while (recordsArr[i].isNotEmpty()) {
+                val now = recordsArr[i].removeFirst().split(":").map { it.toInt() }
+                val usingTime = 23 * 60 + 59 - now[0] * 60 - now[1]
+                feeArr[i] += usingTime
+            }
+        }//In은 했는데 Out은 안한경우 위에서 처리가 안되므로 처음부터 돌면서 23:59에서 빼준다.
+
+
+
+        //요금 계산하기
+        val arr = mutableListOf<Int>()
+        for (i in 0 until 10000) {
+
+            if (feeArr[i] == 0) {
+                continue
+            } else {
+
+                if (feeArr[i] <= fees[0]) {
+                    arr.add(fees[1])
+                    //기본요금 부과
+                } else {
+                    val ceilCheck = (feeArr[i] - fees[0]) % fees[2] != 0//
+                    //올림하라했으므로 올림해야하는지 check해주기
+
+                    var remain = if (ceilCheck) {
+                        (feeArr[i] - fees[0]) / fees[2] + 1
+                    } else {
+                        (feeArr[i] - fees[0]) / fees[2]
+                    }
+
+
+                    arr.add(fees[1] + remain * fees[3])
+
+                }
+            }
+
+        }
+        answer = arr.toIntArray()
+
+
+        return answer
+    }
+
+
+}

src/4week/acw/지름길.kt

@@ -0,0 +1,58 @@
+package `4week`.acw
+
+
+import java.util.*
+
+class `acw지름길` {
+    lateinit var distance: Array<Int>
+    var roads = PriorityQueue(Comparator<Triple<Int, Int, Int>> { a, b ->
+        a.first - b.first
+    })
+
+
+    fun solution() {
+        val (K, D) = readln().split(" ").map { it.toInt() }
+        distance = Array(10001) { it }
+
+
+        for (i in 1..K) {
+            val (s, e, c) = readln().split(" ").map { it.toInt() }
+
+            if (e > D) {
+                continue
+            }
+            //목표보다 높은 지점을 향하는 지름길은 받지 않기
+
+            if (c >= (e - s)) {
+                continue
+            }
+            //지름길이 cost가 더 클경우도 받지 않기
+
+            roads.add(Triple(s, e, c))
+        }
+
+        while (roads.isNotEmpty()) {
+            val (s, e, c) = roads.poll()
+            if (distance[e] - distance[s] > c) {
+                distance[e] = distance[s] + c
+                for (j in e + 1..D) {
+                    if (distance[j - 1] + 1 < distance[j]) {
+                        distance[j] = distance[j - 1] + 1
+                    }
+                }
+                // 지름길을 순회하며 더 최소값일 경우 그 뒤의 node들에 대해서 값 갱신
+            }
+        }
+
+
+
+        println(distance[D])
+
+
+    }
+}
+
+fun main() {
+    val sol = `acw지름길`()
+    sol.solution()
+}

src/4week/acw/톱니바퀴.kt

@@ -0,0 +1,120 @@
+package `4week`.acw
+
+
+import kotlin.math.pow
+
+//시계방향은 오른쪽shift 반시계는 왼쪽 shift
+const val RIGHT = 5
+const val LEFT = 1
+
+class `acw톱니바퀴` {
+
+    var wheel = Array(4) { 0 }
+    var visit = Array(4) { false }
+    var turn = arrayListOf<Pair<Int, Int>>()
+
+
+    fun addTurn(w: Int, turnD: Int) {
+        //dfs로 들어가면서 회전해야할 것들 turn에 추가해주기
+
+
+        var wheelNowRight = if (wheel[w] and (1 shl RIGHT) != 0) 1 else 0
+        var wheelNowLeft = if (wheel[w] and (1 shl LEFT) != 0) 1 else 0
+
+        if (w - 1 >= 0) {
+            val leftWheelsRight = if (wheel[w - 1] and (1 shl RIGHT) != 0) 1 else 0
+
+            if (wheelNowLeft != leftWheelsRight && !visit[w - 1]) {
+                visit[w - 1] = true
+                turn.add(Pair(w - 1, turnD * -1))
+                addTurn(w - 1, turnD * -1)
+            }
+        }
+
+        if (w + 1 < 4) {
+            val rightWheelsLeft = if (wheel[w + 1] and (1 shl LEFT) != 0) 1 else 0
+            if (wheelNowRight != rightWheelsLeft && !visit[w + 1]) {
+                visit[w + 1] = true
+                turn.add(Pair(w + 1, turnD * -1))
+                addTurn(w + 1, turnD * -1)
+            }
+        }
+
+
+    }
+
+    fun turnWheel() {
+
+        while (turn.isNotEmpty()) {
+            val (w, d) = turn.removeFirst()
+
+            if (d == -1) {
+                //반시계
+                val last = wheel[w] and (1 shl 7)
+
+                wheel[w] = (wheel[w] shl 1) and 255
+                if (last != 0) {
+                    wheel[w]++
+                }
+
+            } else {
+                //시계
+                val first = wheel[w] and 1
+
+                wheel[w] = wheel[w] shr 1
+
+                if (first != 0) {
+                    wheel[w] += 1 shl 7
+                }
+            }
+
+
+        }
+
+    }
+
+
+    fun solution() {
+        repeat(4) {
+            var input = readln()
+            var m = 128
+            var num = 0
+            for (i in input) {
+                num += (i.digitToInt() * m)
+                m /= 2
+            }//숫자로 바꿔서 저장
+            wheel[it] = num
+
+        }
+
+        val turnCnt = readln().toInt()
+        repeat(turnCnt) {
+            val (w, d) = readln().split(" ").map { it.toInt() }
+            turn.add(Pair(w - 1, d))
+            visit[w - 1] = true
+
+
+            addTurn(w - 1, d)//회전해야할 것들 turn List에 추가해주기
+            turnWheel()// turn List에서 빼서 회전시켜주기
+            visit = Array(4) { false } // visit은 다시 사용해야함으로 다시 false로 초기화
+        }
+
+
+        var answer = 0
+        for (i in 0 until 4) {
+            if ((wheel[i] and (1 shl 7)) != 0) {
+                answer += (2.0).pow(i).toInt()
+            }
+        }
+
+
+        println(answer)
+
+
+    }
+}
+
+fun main() {
+    val sol = `acw톱니바퀴`()
+    sol.solution()
+}

src/4week/acw/트리의부모찾기.kt

@@ -0,0 +1,42 @@
+package `4week`.acw
+
+class `acw트리의부모찾기` {
+    lateinit var treeMap: Array<MutableList<Int>>
+    lateinit var parent: Array<Int>
+    var N = 0
+
+    fun dfs(p: Int) {
+        //p로 전달받은 노드는 부모란 뜻이니까 연결된 노드들은 자식으로 처리해주기
+        //dfs로 이어가면서 같은 처리 해주기
+        for (child in treeMap[p]) {
+            parent[child] = p
+            treeMap[child].remove(p)
+            dfs(child)
+        }
+    }
+
+
+    fun solution() {
+        N = readln().toInt()
+        treeMap = Array(N + 1) { mutableListOf() }
+        parent = Array(N + 1) { 0 }
+
+        for (i in 1 until N) {
+            val (a, b) = readln().split(" ").map { it.toInt() }
+            treeMap[a].add(b)
+            treeMap[b].add(a)
+            //일단 입력받을 경우 두 node에 대해 상호 연결하기
+        }
+
+        dfs(1)
+        for (i in 2..N) {
+            println(parent[i])
+        }
+
+    }
+}
+
+fun main() {
+    val sol = `acw트리의부모찾기`()
+    sol.solution()
+}