지름길 해결

Author: ChanwooAn

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

@@ -1,52 +1,52 @@
 package `4week`.acw
 
-class `acw근손실`{
-    lateinit var exerciseKits:List<Int>
-    lateinit var visit:Array<Boolean>
-    var cnt=0
+class `acw근손실` {
+    lateinit var exerciseKits: List<Int>
+    lateinit var visit: Array<Boolean>
+    var cnt = 0
 
 
-
-    fun makeComb(arr:MutableList<Int>,power:Int,day:Int,N:Int,K:Int){
-        var powerNow=power
-        if(arr.isNotEmpty()){
-            powerNow=power+arr.last()-K
+    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)
-        {
+        if (powerNow < 500) {
             return
         }
 
-        if(day==N){
+        if (day == N) {
             cnt++
             return
         }
 
-        for(i in 0 until N){
-            if(visit[i]){
+        for (i in 0 until N) {
+            if (visit[i]) {
                 continue
             }
 
             arr.add(exerciseKits[i])
-            visit[i]=true
-            makeComb(arr,powerNow,day+1,N,K)
+            visit[i] = true
+            makePermutation(arr, powerNow, day + 1, N, K)
             arr.remove(exerciseKits[i])
-            visit[i]=false
+            visit[i] = false
         }
     }
 
 
-    fun solution(){
-        val (N,K)=readln().split(" ").map { it.toInt() }
-        exerciseKits=readln().split(" ").map { it.toInt() }
-        visit=Array(N){false}
-        makeComb(mutableListOf(),500,0,N,K)
+    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

@@ -3,74 +3,56 @@ package `4week`.acw
 
 import java.util.*
 
-class `acw지름길`{
-    lateinit var distance:Array<Int>
-    var roads= arrayListOf<Triple<Int,Int,Int>>()
+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}
 
-        var now=0
-        var nowCost=0
+    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){
+        for (i in 1..K) {
+            val (s, e, c) = readln().split(" ").map { it.toInt() }
+
+            if (e > D) {
                 continue
             }
+            //목표보다 높은 지점을 향하는 지름길은 받지 않기
 
-            if(c>=(e-s)){
+            if (c >= (e - s)) {
                 continue
             }
+            //지름길이 cost가 더 클경우도 받지 않기
 
-            roads.add(Triple(s,e,c))
+            roads.add(Triple(s, e, c))
         }
 
-        while(roads.isNotEmpty()){
-            var now=roads.first()
-            var cost=now.second-now.first-now.third
-            var nowRange=now.first..now.second
-            val arr= LinkedList<Triple<Int,Int,Int>>()
-
-            for(i in 1 until roads.size){
-                val (s,e,c)=roads[i]
-                if(s in nowRange || e in nowRange){
-                    arr.add(Triple(s,e,c))
-                }
-            }
-            arr.add(now)
-            for(i in 0 until arr.size){
-                var costNow=arr[i].second-arr[i].first-arr[i].third
-                for(j in i+1 until arr.size){
-
-                    if(arr[i].second<=arr[j].first || arr[i].first>=arr[j].second){
-                        costNow+=(arr[j].second-arr[j].first-arr[j].third)
+        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
                     }
                 }
-                if(costNow>cost){
-                    cost=costNow
-                }
-
-            }//겹치는 것들 중 구성할 수 있는 최대 값 구성
-            distance[D]-=cost
-
-
-            roads.removeAll(arr)
-
-
+                // 지름길을 순회하며 더 최소값일 경우 그 뒤의 node들에 대해서 값 갱신
+            }
         }
 
 
 
-
         println(distance[D])
 
 
     }
 }
-fun main(){
-    val sol =`acw지름길`()
+
+fun main() {
+    val sol = `acw지름길`()
     sol.solution()
 }

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

@@ -4,65 +4,65 @@ package `4week`.acw
 import kotlin.math.pow
 
 //시계방향은 오른쪽shift 반시계는 왼쪽 shift
-const val RIGHT=5
-const val LEFT=1
+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>>()
+class `acw톱니바퀴` {
+    var wheel = Array(4) { 0 }
+    var visit = Array(4) { false }
+    var turn = arrayListOf<Pair<Int, Int>>()
 
 
-    fun addTurn(w:Int,turnD:Int){
+    fun addTurn(w: Int, turnD: Int) {
 
 
-
-        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
+        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
         println("$w $wheelNowLeft $wheelNowRight")
 
-        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 > 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)
+        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()
+    fun turnWheel() {
+
+        while (turn.isNotEmpty()) {
+            val (w, d) = turn.removeFirst()
 
-            if(d==-1){
+            if (d == -1) {
                 //반시계
-                val last=wheel[w] and (1 shl 7)
+                val last = wheel[w] and (1 shl 7)
 
-                wheel[w]=wheel[w] shl 1
-                if(last!=0){
+                wheel[w] = wheel[w] shl 1
+                if (last != 0) {
                     wheel[w]++
                 }
 
-            }else{
+            } else {
                 //시계
-                val first=wheel[w] and 1
+                val first = wheel[w] and 1
 
-                wheel[w]=wheel[w] shr 1
+                wheel[w] = wheel[w] shr 1
 
-                if(first!=0){
-                    wheel[w]+=1 shl 7
+                if (first != 0) {
+                    wheel[w] += 1 shl 7
                 }
             }
 
@@ -72,51 +72,51 @@ class `acw톱니바퀴`{
     }
 
 
-    fun solution(){
-        repeat(4){
-            var input=readln()
-            var m=128
-            var num=0
-            for(i in input){
-                num+=(i.digitToInt()*m)
-                m/=2
+    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
+            wheel[it] = num
 
         }
 
-        val turnCnt=readln().toInt()
-        repeat(turnCnt){
-            val (w,d)=readln().split(" ").map{it.toInt()}
-            turn.add(Pair(w,d))
-            visit[w]=true
+        val turnCnt = readln().toInt()
+        repeat(turnCnt) {
+            val (w, d) = readln().split(" ").map { it.toInt() }
+            turn.add(Pair(w, d))
+            visit[w] = true
 
 
-            addTurn(w,d)
+            addTurn(w, d)
             println(turn)
             turnWheel()
-            for( i in wheel){
+            for (i in wheel) {
                 println(i)
             }
-            visit=Array(4){false}
+            visit = Array(4) { false }
         }
 
 
-        var answer=0
-        for(i in 0 until 4){
-            if((wheel[i] and (1 shr 7))==0){
-                answer+=(2.0).pow(i).toInt()
+        var answer = 0
+        for (i in 0 until 4) {
+            if ((wheel[i] and (1 shr 7)) == 0) {
+                answer += (2.0).pow(i).toInt()
             }
         }
 
 
         println(answer)
 
 
-
     }
 }
-fun main(){
-    val sol=`acw톱니바퀴`()
+
+fun main() {
+    val sol = `acw톱니바퀴`()
     sol.solution()
 }