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 C (GCC 5.4.1) (judge verdict: Runtime Error)

#include <stdio.h>
#include <stdlib.h>

typedef enum {false, true} bool;

int main(void)
{
    int H, W;
    int HxW;
    bool *A;
    int *Q;
    char c;
    int i, j;
    int front, rear;
    int ctr;
    bool flag;
    
    
    scanf("%d%c%d%c", &H, &c, &W, &c);
    
    HxW = H*W;
    
    
    A = (bool*)malloc(sizeof(bool)*HxW);
    Q = (int*)malloc(sizeof(int)*HxW);
    
    
    front = rear = 0;
    
    
    for(i=0; i<H; i++)
    {
        for(j=0; j<W; j++)
        {
            scanf("%c", &c);
            
            if(c == '.')
                A[i*H+j] = false;
            else
            {
                A[i*H+j] = true;
                Q[rear++] = i*H+j;
            }
        }
        scanf("%c", &c);
    }
    
    
    ctr = 0;
    
    
    while(front != rear)
    {
        flag = false;
        
        i = rear-front;
        
        while(i-- > 0)
        {
            
            
            if(Q[front]%W > 0 && Q[front]-1 >= 0 && !A[Q[front]-1])
            {
                A[Q[front]-1] = true;
                Q[rear++] = Q[front]-1;
                
                flag = true;
            }
            
            if((Q[front]+1)%W > 0 && Q[front]+1 < HxW  && !A[Q[front]+1])
            {
                A[Q[front]+1] = true;
                Q[rear++] = Q[front]+1;
                
                flag = true;
            }
            
            if(Q[front]-W >= 0 && !A[Q[front]-W])
            {
                A[Q[front]-W] = true;
                Q[rear++] = Q[front]-W;
                
                flag = true;
            }
            
            if(Q[front]+W < HxW  && !A[Q[front]+W])
            {
                A[Q[front]+W] = true;
                Q[rear++] = Q[front]+W;
                
                flag = true;
            }
            
            front++;
        }
        
        if(flag)
            ctr++;
    }
    
    
    printf("%d\n", ctr);
    
    
    free(A);
    free(Q);
    
    
    //system("pause");
    
    return 0;
}