Problem:
Score : 300 points

Problem Statement

You are given a grid of squares with H horizontal rows and W vertical columns, where each square is painted white or black.
HW characters from A_{11} to A_{HW} represent the colors of the squares.
A_{ij} is # if the square at the i-th row from the top and the j-th column from the left is black, and A_{ij} is . if that square is white.

We will repeatedly perform the following operation until all the squares are black:

Every white square that shares a side with a black square, becomes black.

Find the number of operations that will be performed.
The initial grid has at least one black square.

Constraints

1 \leq H,W \leq 1000

A_{ij} is # or ..

The given grid has at least one black square.

Input

Input is given from Standard Input in the following format:

H W
A_{11}A_{12}...A_{1W}
:
A_{H1}A_{H2}...A_{HW}

Output

Print the number of operations that will be performed.

Sample Input 1

3 3
...
.#.
...

Sample Output 1

2

After one operation, all but the corners of the grid will be black. After one more operation, all the squares will be black.

Sample Input 2

6 6
..#..#
......
#..#..
......
.#....
....#.

Sample Output 2

3

Solution in Kotlin (1.0.0) (judge verdict: Runtime Error)


import java.util.*

fun main(args: Array<String>) {

    DarkerandDarker.init()
    DarkerandDarker.execute()
}


class DarkerandDarker {

    companion object {

        private val scanner = Scanner(System.`in`)

        private var H = 0
        private var W = 0

        private lateinit var table: Array<Array<Boolean>>

        fun init() {
//            val inputs = readLine()!!.split(" ")
            H = scanner.nextInt()
            W = scanner.nextInt()

            table = Array(H) {
                scanner.next().map {
                    it == '#'
                }.toTypedArray()
            }
        }

        fun execute() {
            var roundNum = 0

            var blackCells = mutableSetOf<Pair<Int, Int>>()

            // 初期は総なめ
            for (w in 0 until W) {
                for (h in 0 until H) {
                    if (table[w][h]) {
                        blackCells.add(Pair(h, w))
                    }
                }
            }

            var blackCellNum = blackCells.size

            while (true) {

                if (blackCellNum == H * W) {
                    println(roundNum)
                    break
                }

                val nextBlackCells = mutableSetOf<Pair<Int, Int>>()

                for (cell in blackCells) {

                    val w = cell.first
                    val h = cell.second

                    if (h + 1 != H && !table[h + 1][w]) {
                        table[h + 1][w] = true
                        nextBlackCells.add(Pair(h + 1, w))
                    }
                    if (w + 1 != W && !table[h][w + 1]) {
                        table[h][w + 1] = true
                        nextBlackCells.add(Pair(h, w + 1))
                    }
                    if (h - 1 != -1 && !table[h - 1][w]) {
                        table[h - 1][w] = true
                        nextBlackCells.add(Pair(h - 1, w))
                    }
                    if (w - 1 != -1 && !table[h][w - 1]) {
                        table[h][w - 1] = true
                        nextBlackCells.add(Pair(h, w - 1))

                    }
                }

                // 黒いマスの数
                blackCellNum += nextBlackCells.size
                blackCells = nextBlackCells

                roundNum++
            }
        }

    }
}