// 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.104169070837631x):
#include <bits/stdc++.h>

using namespace std;

#define mp make_pair

#define fi first

#define se second

int n , m , maxi , dx[5] , dy[5];

char grid[2000][2000];

bool cek[2000][2000];

typedef pair<pair<int , int>,int> iii;

iii a;

queue<iii>q;

int main(){

	cin >> n >> m;

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

		for(int j = 1 ; j <= m ; j++){

			cin >> grid[i][j];

			if(grid[i][j] == '#'){

				q.push(mp(mp(i , j) , 0));

			}

		}

	}

	dx[1] = 1;

	dx[2] = -1;

	dx[3] = 0;

	dx[4] = 0;

	dy[1] = 0;

	dy[2] = 0;

	dy[3] = 1;

	dy[4] = -1;

	maxi = 0;

	while(!q.empty()){

		a = q.front();

		int x = a.fi.fi;

		int y = a.fi.se;

		int z = a.se;

		maxi = max(maxi , z);

		q.pop();

		if(cek[x][y])continue;

		cek[x][y] = true;

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

			if(x + dx[i] < 1 || x + dx[i] > n || y + dy[i] < 1  || y + dy[i] > m)continue;

			q.push(mp(mp(x + dx[i], y + dy[i]) , z + 1));

		}

	}

	maxi -= 1;

	if(maxi < 0)cout << 0 << endl;

	else cout << maxi << endl;

}