// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



typedef long long ll;

typedef long double ld;

typedef double db;

typedef string str;



typedef pair<int, int> pi;

typedef pair<ll,ll> pl;

typedef pair<ld,ld> pd;



typedef vector<int> vi;

typedef vector<ll> vl;

typedef vector<ld> vd;

typedef vector<str> vs;

typedef vector<pi> vpi;

typedef vector<pl> vpl;



#define FOR(i,a,b) for (int i = (a); i < (b); ++i)

#define F0R(i,a) FOR(i,0,a)

#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)

#define R0F(i,a) ROF(i,0,a)

#define trav(a,x) for (auto& a: x)



#define sz(x) (int)x.size()

#define all(x) begin(x), end(x)

#define rall(x) rbegin(x), rend(x)

#define rsz resize

#define ins insert



#define mp make_pair

#define pb push_back

#define eb emplace_back

#define f first

#define s second

#define lb lower_bound

#define ub upper_bound



const int MOD = 1e9+7; ///Lifehack: +2*MOD

const int NMAX = 2e5+5;

const ll INF = 1e18;

const ld PI = 4*atan((ld)1);



namespace input {

	template<class T> void re(complex<T>& x);

	template<class T1, class T2> void re(pair<T1,T2>& p);

	template<class T> void re(vector<T>& a);

	template<class T, size_t SZ> void re(array<T,SZ>& a);



	template<class T> void re(T& x) { cin >> x; }

	template<class T, class... Ts> void re(T& t, Ts&... ts) {

		re(t); re(ts...);

	}



	template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }

	template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }

	template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }

	template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }

}



using namespace input;



namespace output {

	void pr(int x) { cout << x; }

	void pr(long x) { cout << x; }

	void pr(ll x) { cout << x; }

	void pr(unsigned x) { cout << x; }

	void pr(unsigned long x) { cout << x; }

	void pr(unsigned long long x) { cout << x; }

	void pr(float x) { cout << x; }

	void pr(double x) { cout << x; }

	void pr(ld x) { cout << x; }

	void pr(char x) { cout << x; }

	void pr(const char* x) { cout << x; }

	void pr(const string& x) { cout << x; }

	void pr(bool x) { pr(x ? "true" : "false"); }

	template<class T> void pr(const complex<T>& x) { cout << x; }



	template<class T1, class T2> void pr(const pair<T1,T2>& x);

	template<class T> void pr(const T& x);



	template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {

		pr(t); pr(ts...);

	}

	template<class T1, class T2> void pr(const pair<T1,T2>& x) {

		pr("{",x.f,", ",x.s,"}");

	}

	template<class T> void pr(const T& x) {

		pr("{"); // const iterator needed for vector<bool>

		bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0;

		pr("}");

	}



	void ps() { pr("\n"); } // print w/ spaces

	template<class T, class... Ts> void ps(const T& t, const Ts&... ts) {

		pr(t); if (sizeof...(ts)) pr(" "); ps(ts...);

	}



	void pc() { pr("]\n"); } // debug w/ commas

	template<class T, class... Ts> void pc(const T& t, const Ts&... ts) {

		pr(t); if (sizeof...(ts)) pr(", "); pc(ts...);

	}

	#define dbg(x...) pr("[",#x,"] = ["), pc(x);

}

using namespace output;



int n,m,cate,ans;

int M[1005][1005];

bool uz[1005][1005];

int cand[1005][1005];

int dl[]={0,-1,0,1,0};

int dc[]={0,0,1,0,-1};

char x;

pair<int,int>k;

queue<pair<int,int>>coada;

void solve() {

re(n,m);

memset(M,2,sizeof(M));

cin.get();

FOR(i,1,n+1){

FOR(j,1,m+1)

   {re(x);if(x=='#')M[i][j]=1,cate++,coada.push({i,j});else M[i][j]=0;}

cin.get();

}

while(!coada.empty())

     {k=coada.front();

      coada.pop();

      for(int ii=1;ii<=4;ii++)

        if(M[k.f+dl[ii]][k.s+dc[ii]]==0)

           M[k.f+dl[ii]][k.s+dc[ii]]=1,cate++,cand[k.f+dl[ii]][k.s+dc[ii]]=1+cand[k.f][k.s],coada.push({k.f+dl[ii],k.s+dc[ii]});

     if(cate==n*m)

        break;

     }

if(cate==n*m)

  FOR(i,1,n+1)

  FOR(j,1,m+1)

    ans=max(ans,cand[i][j]);

pr(ans);

}



int main() {

	ios_base::sync_with_stdio(false); cin.tie(0);

	int t=1;

    //cin>>t;

  	while(t--)

         solve();

    return 0;



}


// Faster C++ solution for the same problem (measured speedup: 5.216541730036809x):
#include<bits/stdc++.h>

using namespace std;

const int maxn = 1000 + 7, maxm = 1e6 + 7;

int D[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

int n, m, vis[maxn][maxn];

char r[maxn];



struct Node{

	int x, y;

}node[maxm];

int s = 1, t = 0;



void bfs() {

	int x, y, X, Y;

	while(s <= t) {

		x = node[s].x; y = node[s].y;

		++s;

		for (int i = 0; i < 4; ++i) {

			X = x + D[i][0];

			Y = y + D[i][1];

			if(~vis[X][Y]) continue;

			vis[X][Y] = vis[x][y] + 1;

			node[++t].x = X; node[t].y = Y;

		}

	}

	printf("%d\n", vis[x][y]);

}



int main() {

	scanf("%d%d", &n, &m);

	for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) vis[i][j] = -1;

	for (int i = 1; i <= n; ++i) {

		scanf("%s", r + 1);

		for (int j = 1; j <= m; ++j) if(r[j] == '#') {

			node[++t].x = i; node[t].y = j;

			vis[i][j] = 0;

		}

	}

	bfs();

	return 0;

}