[Week3] 안찬우 : 킹, 랜선 자르기, 크로스워드, 단풍잎이야기

src/3week/acw/단풍잎이야기.kt

@@ -0,0 +1,57 @@
+package `3week`.acw
+
+class 단풍잎이야기{
+    lateinit var quests:Array<Array<Int>>
+    lateinit var comb:Array<Boolean>
+    var answer=0
+    fun makeComb(arr:MutableList<Int>,targetNum:Int,count:Int,start:Int){
+        if(count==targetNum){
+
+            for(i in 1 until 2*targetNum+1){
+                if(comb[i]){
+                    arr.add(i)
+                }
+            }
+            answer=answer.coerceAtLeast(countQuests(arr))
+
+            arr.clear()
+
+            return
+        }
+
+        for(i in start .. 2*targetNum){
+            comb[i]=true
+            makeComb(arr,targetNum,count+1,i+1)
+            comb[i]=false
+        }
+    }
+    fun countQuests(arr:List<Int>):Int{
+        var count=0
+        loop1@for(i in quests){
+            for(j in i){
+                if(!arr.contains(j)) {
+                    continue@loop1
+                }
+            }
+
+            count++
+        }
+        return count
+    }
+    fun solution(){
+        val (n,m,k)=readln().split(" ").map{it.toInt()}
+        quests=Array(m){readln().split(" ").map{it.toInt()}.toTypedArray()}
+        comb=Array(2*n+1){false }
+
+        makeComb(mutableListOf(),n,0,1)
+
+        println(answer)
+
+
+    }
+}
+fun main() {
+    val sol = 단풍잎이야기()
+    sol.solution()
+}
+

src/3week/acw/랜선자르기.kt

@@ -0,0 +1,55 @@
+package `3week`.acw
+
+import java.util.PriorityQueue
+class 랜선자르기{
+    var answer=0L
+    var test=PriorityQueue<Long>()
+    fun binarySearch(start:Long,end:Long,targetNum:Int){
+
+        if(start>end){
+            return
+        }
+
+        var s:Long=start.toLong()
+        var e:Long=end.toLong()
+        var count=0L
+        val now=((s+e)/2)
+        for(i in test){
+            count+=(i/now)
+
+        }
+
+        if(count<targetNum){
+            binarySearch(s,now-1,targetNum)
+            //작을 땐 더 작은 수로 계산해보기
+        }else{
+            answer=answer.coerceAtLeast(now)
+            binarySearch(now+1,e,targetNum)
+            //크면 더 큰 수 찾아보기
+        }
+
+    }
+
+    fun solution(){
+        val (K,N)= readln().split(" ").map{it.toInt()}
+
+        repeat(K){
+            val input= readln().toLong()
+            test.add(input)
+        }
+        binarySearch(1,test.last(),N)
+
+        println(answer)
+
+
+
+
+
+    }
+}
+fun main() {
+    val sol = 랜선자르기()
+    sol.solution()
+}
+
+

src/3week/acw/크로스워드.kt

@@ -0,0 +1,79 @@
+package `3week`.acw
+
+import java.util.PriorityQueue
+
+class 크로스워드{
+    lateinit var puzzle: Array<String>
+
+    lateinit var size: List<Int>
+
+    val direction = listOf<Pair<Int, Int>>(
+        Pair(0, -1),
+        Pair(0, 1),
+        Pair(1, 0),
+        Pair(-1, 0)
+    )
+
+    var words = PriorityQueue<String>()
+
+    fun isIsolate(y:Int,x:Int):Boolean{
+        for(i in 0 until 4){
+            val ny=y+direction[i].first
+            val nx=x+direction[i].second
+
+            if(ny<0 || nx<0 || ny>=size[0] ||nx>=size[1]){
+                continue
+            }
+
+            if(puzzle[ny][nx] !in 'a'..'z'){
+                return false
+            }
+        }
+
+        return true
+    }
+
+    fun solution() {
+
+        size = readln().split(" ").map { it.toInt() }
+
+        puzzle = Array(size[0]){ readln() }
+
+        //visit = Array(size[0]) { Array(size[1]) { false } }
+
+        repeat(size[0]){
+            puzzle[it].split("#").map {
+                if(it.length>1){
+                    words.add(it)
+                }
+            }
+
+        }//가로
+
+        repeat(size[1]){
+            var word=""
+            for(i in 0 until size[0]){
+                word+=puzzle[i][it]
+            }
+            word.split("#").map {
+                if(it.length>1){
+                    words.add(it)
+                }
+            }
+        }//세로
+
+        for(i in 0 until size[0]){
+            for(j in 0 until size[1]){
+                isIsolate(i,j)
+            }
+        }
+
+
+        println(words.first())
+
+    }
+}
+fun main(){
+    val sol = 크로스워드()
+    sol.solution()
+}

src/3week/acw/킹.kt

@@ -0,0 +1,97 @@
+package `3week`.acw
+
+const val king=3
+const val stone=2
+class 킹{
+    lateinit var input:List<String>
+    var chessMap=Array(8){Array(8){0} }
+
+    val direction= hashMapOf<String,Pair<Int,Int>>(
+        Pair("R",Pair(0,1)),
+        Pair("L",Pair(0,-1)),
+        Pair("B",Pair(1,0)),
+        Pair("T",Pair(-1,0)),
+        Pair("RT",Pair(-1,1)),
+        Pair("LT",Pair(-1,-1)),
+        Pair("RB",Pair(1,1)),
+        Pair("LB",Pair(1,-1))
+    )
+
+
+    fun validate(y:Int,x:Int):Boolean{
+        return !(y<0 || x<0 || y>7 || x>7)
+    }
+
+    fun solution(){
+        input=readln().split(" ")
+
+        var kingX=input[0][0]-'A'
+        var kingY=8-input[0][1].digitToInt()
+
+        var stoneX=input[1][0]-'A'
+        var stoneY=8-input[1][1].digitToInt()
+
+        val N=input[2].toInt()
+
+        chessMap[kingY][kingX]=king
+        //king
+
+        chessMap[stoneY][stoneX]=stone
+        //stone
+
+        for( i in 0 until N){
+            val mv=readln()
+
+            val ny=kingY+direction[mv]!!.first
+            val nx=kingX+direction[mv]!!.second
+            if(!validate(ny,nx)){
+                continue
+            }//유효성 check
+
+            if(chessMap[ny][nx]==stone){
+                val nsy=stoneY+direction[mv]!!.first
+                val nsx=stoneX+direction[mv]!!.second
+
+                if(!validate(nsy,nsx)){
+                    continue
+                }//돌이 자리를 비켜주지 못할 때
+                else{
+                    chessMap[stoneY][stoneX]=0
+                    chessMap[kingY][kingX]=0
+
+                    chessMap[nsy][nsx]=stone
+                    chessMap[ny][nx]=king
+
+                    kingY=ny
+                    kingX=nx
+
+                    stoneY=nsy
+                    stoneX=nsx
+                    //이동시켜주기
+
+                    continue
+                }
+
+            }//가는 자리에 돌이 있을 때
+
+
+            chessMap[kingY][kingX]=0
+            chessMap[ny][nx]=king
+            kingY=ny
+            kingX=nx
+            //아무문제 없으면 king만 이동
+
+        }
+
+
+
+        println("${(kingX+'A'.toInt()).toChar()}${8-kingY}\n${(stoneX+'A'.toInt()).toChar()}${8-stoneY}")
+
+    }
+}
+
+
+fun main(){
+    val sol = 킹()
+    sol.solution()
+}