output_description: Print the number of operations that will be performed.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      A_{11}A_{12}...A_{1W}
      :
      A_{H1}A_{H2}...A_{HW}
attempt: def main():
      import sys
  
      input = sys.stdin.readline
      h, w = map(int, input().split())
      a = []
      for i in range(h):
          inp = list(input())
          a.append(inp)
  
      dp = [[10**9] * w for i in range(h)]
  
      for i in range(h):
          for j in range(w):
              if a[i][j] == "." and [i, j] != [0, 0]:
                  if i >= 1:
                      dp[i][j] = dp[i - 1][j] + 1
                      if j >= 1:
                          dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1)
                  else:
                      dp[i][j] = dp[i][j - 1] + 1
              elif a[i][j] == "#":
                  dp[i][j] = 0
      for i in range(h):
          for j in range(w - 1, -1, -1):
              if a[i][j] == "." and [i, j] != [0, w - 1]:
                  if i >= 1:
                      dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j])
                      if j + 1 <= w - 1:
                          dp[i][j] = min(dp[i][j], dp[i][j + 1] + 1)
                  else:
                      dp[i][j] = min(dp[i][j + 1] + 1, dp[i][j])
      for i in range(h - 1, -1, -1):
          for j in range(w):
              if a[i][j] == "." and [i, j] != [h - 1, 0]:
                  if i + 1 <= h - 1:
                      dp[i][j] = min(dp[i + 1][j] + 1, dp[i][j])
                      if j >= 1:
                          dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1)
                  else:
                      dp[i][j] = min(dp[i][j - 1] + 1, dp[i][j])
      for i in range(h - 1, -1, -1):
          for j in range(w - 1, -1, -1):
              if a[i][j] == "." and [i, j] != [h - 1, w - 1]:
                  if i + 1 <= h - 1:
                      dp[i][j] = min(dp[i + 1][j] + 1, dp[i][j])
                      if j + 1 <= w - 1:
                          dp[i][j] = min(dp[i][j], dp[i][j + 1] + 1)
                  else:
                      dp[i][j] = min(dp[i][j + 1] + 1, dp[i][j])
  
      res = -1
      for i in range(h):
          for j in range(w):
              res = max(res, dp[i][j])
  
      print(res)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: 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.
samples: [{"input": "3 3\n    ...\n    .#.\n    ...", "output": "2\n    \n\nAfter one operation, all but the corners of the grid will be black. After one\nmore operation, all the squares will be black.\n\n* * *"}, {"input": "6 6\n    ..#..#\n    ......\n    #..#..\n    ......\n    .#....\n    ....#.", "output": "3"}]