#pragma GCC optimize ("O3")
#include "bits/stdc++.h"

using namespace std;
using ll = long long int;

#define debugos cout
#define debug(v) {printf("L%d %s > ",__LINE__,#v);debugos<<(v)<<endl;}
#define debugv(v) {printf("L%d %s > ",__LINE__,#v);for(auto e:(v)){debugos<<e<<" ";}debugos<<endl;}
#define debuga(m,w) {printf("L%d %s > ",__LINE__,#m);for(int x=0;x<(w);x++){debugos<<(m)[x]<<" ";}debugos<<endl;}
#define debugaa(m,h,w) {printf("L%d %s >\n",__LINE__,#m);for(int y=0;y<(h);y++){for(int x=0;x<(w);x++){debugos<<(m)[y][x]<<" ";}debugos<<endl;}}
#define all(v) (v).begin(),(v).end()
#define repeat(cnt,l) for(auto cnt=decltype(l)();(cnt)<(l);++(cnt))
#define rrepeat(cnt,l) for(auto cnt=(l)-1;0<=(cnt);--(cnt))
#define iterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);++(cnt))
#define diterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);--(cnt))
const ll MD = 1000000007ll; const long double PI = 3.1415926535897932384626433832795L;
inline void assert_call(bool assertion, function<void()> f) { if (!assertion) { cerr << "assertion fault:" << endl; f(); abort(); } }
template<typename T1, typename T2> inline ostream& operator <<(ostream& o, const pair<T1, T2> p) { o << '(' << p.first << ':' << p.second << ')'; return o; }
template<typename Vec> inline ostream& _ostream_vecprint(ostream& os, const Vec& a) {
	os << '['; for (const auto& e : a) os << ' ' << e << ' '; os << ']'; return os;
}
template<typename T> inline ostream& operator<<(ostream & o, const vector<T> & v) { return _ostream_vecprint(o, v); }
template<typename T, size_t S> inline ostream& operator<<(ostream & o, const array<T, S> & v) { return _ostream_vecprint(o, v); }
template<typename T> inline T& chmax(T & to, const T & val) { return to = max(to, val); }
template<typename T> inline T& chmin(T & to, const T & val) { return to = min(to, val); }
void bye(string s, int code = 0) { cout << s << endl; exit(code); }
mt19937_64 randdev(8901016);
template<typename T, typename Random = decltype(randdev), typename enable_if<is_integral<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random & rand = randdev) { return uniform_int_distribution<T>(l, h)(rand); }
template<typename T, typename Random = decltype(randdev), typename enable_if<is_floating_point<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random & rand = randdev) { return uniform_real_distribution<T>(l, h)(rand); }

#if defined(_WIN32) || defined(_WIN64)
#define getc_x _getc_nolock
#define putc_x _putc_nolock
#elif defined(__GNUC__)
#define getc_x getc_unlocked
#define putc_x putc_unlocked
#else
#define getc_x getc
#define putc_x putc
#endif
#define isvisiblechar(c) (0x21<=(c)&&(c)<=0x7E)
class MaiScanner {
	FILE* fp_;
public:
	inline MaiScanner(FILE* fp) :fp_(fp) {}
	template<typename T> void input_integer(T& var) noexcept {
		var = 0; T sign = 1;
		int cc = getc_x(fp_);
		for (; cc < '0' || '9' < cc; cc = getc_x(fp_))
			if (cc == '-') sign = -1;
		for (; '0' <= cc && cc <= '9'; cc = getc_x(fp_))
			var = (var << 3) + (var << 1) + cc - '0';
		var = var * sign;
	}
	inline int c() noexcept { return getc_x(fp_); }
	inline MaiScanner& operator>>(int& var) noexcept { input_integer<int>(var); return *this; }
	inline MaiScanner& operator>>(long long& var) noexcept { input_integer<long long>(var); return *this; }
	inline MaiScanner& operator>>(string & var) {
		int cc = getc_x(fp_);
		for (; !isvisiblechar(cc); cc = getc_x(fp_));
		for (; isvisiblechar(cc); cc = getc_x(fp_))
			var.push_back(cc);
		return *this;
	}
	template<typename IT> inline void in(IT begin, IT end) { for (auto it = begin; it != end; ++it) * this >> *it; }
};
class MaiPrinter {
	FILE* fp_;
public:
	inline MaiPrinter(FILE* fp) :fp_(fp) {}
	template<typename T>
	void output_integer(T var) noexcept {
		if (var == 0) { putc_x('0', fp_); return; }
		if (var < 0)
			putc_x('-', fp_),
			var = -var;
		char stack[32]; int stack_p = 0;
		while (var)
			stack[stack_p++] = '0' + (var % 10),
			var /= 10;
		while (stack_p)
			putc_x(stack[--stack_p], fp_);
	}
	inline MaiPrinter& operator<<(char c) noexcept { putc_x(c, fp_); return *this; }
	inline MaiPrinter& operator<<(int var) noexcept { output_integer<int>(var); return *this; }
	inline MaiPrinter& operator<<(long long var) noexcept { output_integer<long long>(var); return *this; }
	inline MaiPrinter& operator<<(char* str_p) noexcept { while (*str_p) putc_x(*(str_p++), fp_); return *this; }
	inline MaiPrinter& operator<<(const string& str) {
		const char* p = str.c_str();
		const char* l = p + str.size();
		while (p < l) putc_x(*p++, fp_);
		return *this;
	}
	template<typename IT> void join(IT begin, IT end, char sep = ' ') { for (bool b = 0; begin != end; ++begin, b = 1) b ? *this << sep << *begin : *this << *begin; }
};
MaiScanner scanner(stdin);
MaiPrinter printer(stdout);

struct P {
	using T = int;
	T y, x;

	P(T _y = 0, T _x = 0) :y(_y), x(_x) {}

	inline bool operator == (P p) const { return y == p.y && x == p.x; }
	inline bool operator < (P p) const { return y == p.y ? x < p.x : y < p.y; }
	inline P operator+(P p) const { return P(y + p.y, x + p.x); }
	inline P operator-(P p) const { return P(y - p.y, x - p.x); }
	inline P& operator+=(P p) { y += p.y; x += p.x; return *this; }
	inline P& operator-=(P p) { y -= p.y; x -= p.x; return *this; }
	inline P& operator-=(T m) { y *= m; x; return *this; }
	inline T distM(P p) const { return abs(y - p.y) + abs(x - p.x); }
	inline T distC(P p) const { return max(abs(y - p.y), abs(x - p.x)); }
	template<typename ITR> ITR nearestM(ITR begin, ITR end) const {
		if (begin == end) return end;
		T best = distM(*begin);
		ITR besti = begin;
		for (ITR it = begin; ++it, it != end;) {
			T m = distM(*it);
			if (best < m) {
				best = m;
				besti = it;
			}
		}
		return besti;
	}
};
inline ostream& operator<<(ostream & os, P p) { os << '(' << p.y << ',' << p.x << ')'; return os; }

const P FourMoving[] = { P(-1,0),P(0,1), P(1,0), P(0,-1) };
const P FiveMoving[] = { P(-1,0),P(0,1), P(1,0), P(0,-1), P(0,0) };
const P EightMoving[] = { P(-1,0),P(0,1), P(1,0), P(0,-1), P(-1,-1), P(-1,1), P(1,-1), P(1,1) };

inline P operator*(P::T m, P p) noexcept { return P(m * p.y, m * p.x); }

template<typename T>
// using T = int;
struct F {
	int height, width;
	vector<T> data;

	F(int h = 1, int w = 1) :height(h), width(w), data(h* w) {}

	inline T& operator()(int y, int x) { return data[x + y * width]; }
	inline T& operator()(P p) { return data[p.x + p.y * width]; }
	inline T operator()(int y, int x) const { return data[x + y * width]; }
	inline T operator()(P p) const { return data[p.x + p.y * width]; }

	inline bool safe(int y, int x) const { return 0 <= y && y < height && 0 <= x && x < width; }
	inline bool safe(P p) const { return 0 <= p.y && p.y < height && 0 <= p.x && p.x < width; }

	inline void fill(T e) { std::fill(ALL(data), e); }
	inline void resize(int h, int w) { height = h; width = w; data.resize(h * w); }

	void print(ostream& os, int setw_arg = 4) {
		for (int y = 0; y < height; ++y) {
			for (int x = 0; x < width; ++x)
				os << setw(setw_arg) << operator()(y, x) << ' ';
			os << '\n';
		}
	}
};


//



int H, W;


//


int main() {

	scanner >> H >> W;
	F<int> field(H, W);

	queue<P> qu;

	repeat(i, H) {
		string str;
		scanner >> str;
		repeat(j, W) {
			field(i, j) = str[j] == '#' ? 1 : 0;
			if (str[j] == '#')
				qu.emplace(i, j);
		}
	}

	int ma = 1;

	while (!qu.empty()) {
		auto p = qu.front(); qu.pop();
		auto t = field(p);
		for (auto v : FourMoving) {
			auto p2 = p + v;
			if (!field.safe(p2)) continue;
			if (field(p2) == 0) {
				field(p2) = t + 1;
				chmax(ma, t + 1);
				qu.push(p2);
			}
		}
	}

	cout << (ma-1) << endl;


	return 0;
}



Measured memory_bytes: 12304