[백준] 단지번호붙이기 (2667)(Kotlin)

원본 문제 :https://www.acmicpc.net/problem/2667

문제 참고 :https://ballpython.tistory.com/7

 

<첫번째>

import java.io.*

var visited: Array<BooleanArray> = arrayOf()
var map: Array<IntArray> = arrayOf()
var rectangleSize = 0
var cnt: Int = 0
val dx: IntArray = intArrayOf(-1,1,0,0)
val dy: IntArray = intArrayOf(0,0,-1,1)



fun main() = with(BufferedReader(InputStreamReader(System.`in`))){

    rectangleSize = readLine().toInt()
    map = Array(rectangleSize, {IntArray(rectangleSize)})
    visited = Array( rectangleSize, { BooleanArray(rectangleSize) } )

    val list: MutableList<Int> = mutableListOf()


    for (i in 0 until rectangleSize) {
        val str = readLine()
        for(j in 0 until rectangleSize) {
            map[i][j] = (str[j] + "").toInt()
            visited[i][j] = false
        }
    }

    for (i in 0 until rectangleSize) {
        for (j in 0 until rectangleSize) {
            if (map[i][j] == 1 && visited[i][j] == false) {
                cnt = 1
                dfs(i,j)
                list.add(cnt)
            }
        }
    }

    list.sort()
    println(list.size)
    for (i in list)
        println(i)
}

fun dfs(x: Int, y: Int): Int {
    visited[x][y] = true

    for (i in 0 until 4) {
        val nx = x + dx[i]
        val ny = y + dy[i]

        if(nx>=0 && ny >= 0 && nx < rectangleSize && ny < rectangleSize){
            if (map[nx][ny] == 1 && visited[nx][ny] == false) {
                dfs(nx, ny)
                cnt++
            }
        }
    }

    return cnt
}

 

<두번째> 2020/06/08

import java.io.BufferedReader
import java.io.InputStreamReader

var size: Int = 0
var matrix: Array<IntArray> = arrayOf<IntArray>()
var visited: Array<BooleanArray> = arrayOf<BooleanArray>()
var cnt: Int = 0

val dx = intArrayOf(1,-1,0,0)
val dy = intArrayOf(0,0,1,-1)

fun dfs(x: Int, y: Int) {

    visited[x][y] = true

    for (i in 0 until 4) {
        val nx = x + dx[i]
        val ny = y + dy[i]

        if (nx in 0 .. size - 1 && ny in 0 .. size - 1) {
            if (matrix[nx][ny] != 0 && !visited[nx][ny]) {
                dfs(nx, ny)
                cnt++
            }
        }
    }
}

fun main() = with(BufferedReader(InputStreamReader(System.`in`))) {

    size = readLine().toInt()
    matrix = Array(size) { IntArray(size) }
            .map {
                readLine().map{ it.toInt() - 48 }.toIntArray()
            }.toTypedArray()

    visited = Array(size) { BooleanArray(size) { false } }

    val map: MutableMap<Int, Int> = mutableMapOf()
    var blocks: Int = 0

    for (i in 0 until size) {
        for (j in 0 until size) {
            if (!visited[i][j] && matrix[i][j] != 0) {
                cnt++
                dfs(i, j)
                map.put(++blocks, cnt)
                cnt = 0
            }
        }
    }

    println(map.size)
    map.toList().sortedBy { it.first }.forEach { println(it.second) }

}