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 Go (1.6) (judge verdict: Runtime Error)

package main

import (
	"fmt"
	"math"
	"os"
	"strings"
)

var H, W int
var A [][]Point

//var whiteNum int

type Point struct {
	x, y   int
	color  int
	isDone bool
}

func abs(a int) int {
	return int(math.Abs(float64(a)))
}

func (p Point) findNearestBlackDistance() (int, int, int) {
	i := 1
	var x, y1, y2 int
	for {
		for j := -1 * i; j <= i; j++ {
			k := i - abs(j)
			x = p.x + j
			y1 = p.y + k
			y2 = p.y - k
			if x >= 0 && y1 >= 0 && x < W && y1 < H {
				if A[y1][x].color == 1 {
					return i, y1, x
				}
			}
			if x >= 0 && y2 >= 0 && x < W && y2 < H {
				if A[y2][x].color == 1 {
					return i, y2, x
				}
			}

		}
		i += 1
	}
	return -1, -1, -1
}

func (p Point) doWhitesWithDistance(distance int) {
	var x, y1, y2 int
	for i := 1; i <= distance; i++ {
		for j := -1 * i; j <= i; j++ {
			k := i - abs(j)
			x = p.x + j
			y1 = p.y + k
			y2 = p.y - k
			if x >= 0 && y1 >= 0 && x < W && y1 < H {
				if A[y1][x].color == 0 {
					if A[y1][x].isDone != true {
						A[y1][x].isDone = true
						//						whiteNum -= 1
					}
				}
			}
			if x >= 0 && y2 >= 0 && x < W && y2 < H {
				if A[y2][x].color == 0 {
					if A[y2][x].isDone != true {
						A[y2][x].isDone = true
						//						whiteNum -= 1
					}
				}
			}
		}
	}
}

func main() {
	fmt.Scan(&H, &W)
	A = make([][]Point, H)
	s := ""
	for i := 0; i < H; i++ {
		A[i] = make([]Point, W)
		fmt.Scan(&s)
		info := strings.Split(s, "")
		for j := 0; j < W; j++ {
			if info[j] == "." {
				A[i][j] = Point{x: j, y: i, color: 0, isDone: false}
			} else {
				A[i][j] = Point{x: j, y: i, color: 1, isDone: true}
			}
		}
	}
	max := 0
	tmp := 0
	var x, y int

	for i := 0; i < H; i++ {
		for j := 0; j < W; j++ {
			if A[i][j].isDone != true {
				tmp, x, y = A[i][j].findNearestBlackDistance()
				if tmp == -1 {
					fmt.Println(max)
					os.Exit(0)
				}
				A[y][x].doWhitesWithDistance(tmp)
				if tmp > max {
					max = tmp
				}
			}
		}
	}
	fmt.Println(max)
}