4week acw

Author: ChanwooAn

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 makeComb(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
+            makeComb(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}
+        makeComb(mutableListOf(),500,0,N,K)
+
+        println(cnt)
+
+    }
+}
+fun main() {
+    val sol = `acw근손실`()
+    sol.solution()
+}
+

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

@@ -0,0 +1,76 @@
+package `4week`.acw
+
+
+import java.util.*
+
+class `acw지름길`{
+    lateinit var distance:Array<Int>
+    var roads= arrayListOf<Triple<Int,Int,Int>>()
+
+    fun solution(){
+        val (K,D)=readln().split(" ").map{it.toInt()}
+        distance=Array(10001){it}
+
+        var now=0
+        var nowCost=0
+
+        for(i in 1..K){
+            val (s,e,c)=readln().split(" ").map{it.toInt()}
+
+            if(e>D){
+                continue
+            }
+
+            if(c>=(e-s)){
+                continue
+            }
+
+            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)
+                    }
+                }
+                if(costNow>cost){
+                    cost=costNow
+                }
+
+            }//겹치는 것들 중 구성할 수 있는 최대 값 구성
+            distance[D]-=cost
+
+
+            roads.removeAll(arr)
+
+
+        }
+
+
+
+
+        println(distance[D])
+
+
+    }
+}
+fun main(){
+    val sol =`acw지름길`()
+    sol.solution()
+}

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

@@ -0,0 +1,122 @@
+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){
+
+
+
+        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<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
+                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,d))
+            visit[w]=true
+
+
+            addTurn(w,d)
+            println(turn)
+            turnWheel()
+            for( i in wheel){
+                println(i)
+            }
+            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()
+            }
+        }
+
+
+        println(answer)
+
+
+
+    }
+}
+fun main(){
+    val sol=`acw톱니바퀴`()
+    sol.solution()
+}

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

@@ -0,0 +1,39 @@
+package `4week`.acw
+
+class `acw트리의부모찾기`{
+    lateinit var treeMap:Array<MutableList<Int>>
+    lateinit var parent:Array<Int>
+    var N=0
+
+    fun dfs(p:Int){
+        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)
+        }
+
+        dfs(1)
+        for(i in 2..N){
+            println(parent[i])
+        }
+
+    }
+}
+fun main(){
+    val sol=`acw트리의부모찾기`()
+    sol.solution()
+}