import java.util.*
import java.math.*
import java.lang.Math.*


private val readString: ()->String = {readLine()!!}
private val readInt: ()->Int = { readLine()!!.toInt() }
private val readLong: ()->Long = { readLine()!!.toLong() }
private val readListInt: ()->List<Int> = { readLine()!!.split(' ').map(String::toInt) }
private val readListLong: ()->List<Long> = { readLine()!!.split(' ').map(String::toLong) }
private val errPrintln: (String)->Unit = { msg -> System.err.println(msg) }


data class Position(var x: Int, var y: Int)

fun solveA(G: Array<String>): Int {
    val H = G.size
    val W = G[0].length
    val INF = Int.MAX_VALUE / 2
    val step = Array(H) { Array<Int>(W){INF} }
    val starts = ArrayList<Position>()
    for (i in 0 until H) {
        for (j in 0 until W) {
            //step[i][j] = INF
            if (G[i][j] == '#') {
                starts.add(Position(i, j))
            }
        }
    }
    val dx = intArrayOf(0, 1, 0, -1)
    val dy = intArrayOf(1, 0, -1, 0)
    val que = ArrayDeque<Position>()
    for (i in starts.indices) {
        que.addLast(starts[i])
        step[starts[i].x][starts[i].y] = 0
    }
    var res = 0
    while (!que.isEmpty()) {
        val pos = que.removeFirst()
        val x = pos.x
        val y = pos.y
        for (i in dx.indices) {
            val nx = x + dx[i]
            val ny = y + dy[i]
            if (nx < 0 || H <= nx || ny < 0 || W <= ny) {
                continue
            }
            if (step[nx][ny] > step[x][y] + 1) {
                step[nx][ny] = step[x][y] + 1
                que.addLast(Position(nx, ny))
                res = max(res, step[nx][ny])
            }
        }
    }
    return res
}


fun main(args: Array<String>) {
    val (H, W) = readListInt()
    val A = Array<String>(H){""}
    for (i in 0 until H) {
        A[i] = readString()
    }

    val ans = solveA(A)

    println(ans)
}
