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



const int MAX_N = int(1e3) + 10;



const int dx[] = {-1, 0, 1, 0};

const int dy[] = {0, -1, 0, 1};



int n, m;

int dis[MAX_N][MAX_N];

bool vis[MAX_N][MAX_N];

char s[MAX_N];

std::vector<std::pair<int, int> > que;



int main() {

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

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

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

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

			if (s[j] == '#') {

				que.emplace_back(i, j);

				vis[i][j] = 1;

				dis[i][j] = 0;

			}

		}

	}



	int ans = 0;

	for (int i = 0; i < que.size(); ++i) {

		int x = que[i].first, y = que[i].second;

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

			int _x = x + dx[k], _y = y + dy[k];

			if (_x >= 1 && _x <= n && _y >= 1 && _y <= m && !vis[_x][_y]) {

				vis[_x][_y] = 1;

				dis[_x][_y] = dis[x][y] + 1;

				que.emplace_back(_x, _y);

				if (dis[_x][_y] > ans) ans = dis[_x][_y];

			}

		}

	}

	printf("%d\n", ans);

}