#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct int2
{
	int x;
	int y;
};

vector<vector<int>> map;
vector<int2> aBorder(0);
vector<int2> bBorder(0);
int2 aPos;
int2 bPos;
int n, m;

static bool Compare(int2 a, int2 b)
{
	return a.x + a.y < b.x + b.y;
}

static void ExploreMap(int v, int x, int y)
{
	map[x][y] = v;
	bool added = false;
	if (x - 1 >= 0)
	{
		if (map[x - 1][y] == 0)
		{
			ExploreMap(v, x - 1, y);
		}
		else
		{
			if (map[x - 1][y] == 1)
			{
				if(v == 2) aBorder.push_back({ x, y });
				else bBorder.push_back({ x, y });
				added = true;
			}
		}
	}

	if (x + 1 < n)
	{
		if (map[x + 1][y] == 0)
		{
			ExploreMap(v, x + 1, y);
		}
		else
		{
			if (map[x + 1][y] == 1 && !added)
			{
				if (v == 2) aBorder.push_back({ x, y });
				else bBorder.push_back({ x, y });
				added = true;
			}
		}
	}

	if (y - 1 >= 0)
	{
		if (map[x][y - 1] == 0)
		{
			ExploreMap(v, x, y - 1);
		}
		else
		{
			if (map[x][y - 1] == 1 && !added)
			{
				if (v == 2) aBorder.push_back({ x, y });
				else bBorder.push_back({ x, y });
				added = true;
			}
		}
	}

	if (y + 1 < m)
	{
		if (map[x][y + 1] == 0)
		{
			ExploreMap(v, x, y + 1);
		}
		else
		{
			if (map[x][y + 1] == 1 && !added)
			{
				if (v == 2) aBorder.push_back({ x, y });
				else bBorder.push_back({ x, y });
			}
		}
	}
}

int main()
{
	cin.tie(nullptr);
	iostream::sync_with_stdio(false);

	char c;
	cin >> n >> m;
	map.resize(n);

	for (int i = 0; i < n; i++)
	{
		map[i].resize(m);
		for (int j = 0; j < m; j++)
		{
			cin >> c;
			map[i][j] = (c == '#' ? 1 : 0);
			if (c == 'A')
			{
				aPos = { i, j };
			}
			if (c == 'B')
			{
				bPos = { i, j };
			}
		}
	}

	ExploreMap(2, aPos.x, aPos.y);

	if (map[bPos.x][bPos.y] != 0)
	{
		cout << 0;
		return 0;
	}
	ExploreMap(3, bPos.x, bPos.y);

	int minimDist = 10000;

	sort(aBorder.begin(), aBorder.end(), Compare);
	sort(bBorder.begin(), bBorder.end(), Compare);
	if (aBorder[0].x + aBorder[0].y < bBorder[0].x + bBorder[0].y)
	{
		for (int i = 0; i < aBorder.size(); i++)
		{
			for (int j = 0; j < bBorder.size(); j++)
			{
				minimDist = min(minimDist, abs(aBorder[i].x - bBorder[j].x) + abs(aBorder[i].y - bBorder[j].y));
				if (bBorder[j].x + bBorder[j].y - aBorder[i].x - aBorder[i].y >= minimDist) break;
			}
			if (minimDist == 2) break;
		}
	}
	else
	{
		for (int i = 0; i < bBorder.size(); i++)
		{
			for (int j = 0; j < aBorder.size(); j++)
			{
				minimDist = min(minimDist, abs(bBorder[i].x - aBorder[j].x) + abs(bBorder[i].y - aBorder[j].y));
				if (aBorder[j].x + aBorder[j].y - bBorder[i].x - bBorder[i].y >= minimDist) break;
			}
			if (minimDist == 2) break;
		}
	}

	
	cout << minimDist;
}