核心思路是通过多源BFS预处理起点和终点的可达区域，再计算每个点到最近起点和终点的距离之和。具体步骤：

1. 分别BFS起点$（1,1）$和终点$（n,m）$的可达点（不穿过障碍物）；
2. 对每个点计算$d1[i][j]$（到最近起点可达点的距离）和$d2[i][j]$（到最近终点可达点的距离）；
3. 答案为所有点中$d1[i][j] + d2[i][j] - 1$的最小值，若起点终点直接可达则结果为0。
   时间复杂度为$O(nm)$，通过双$BFS$实现。

#include<bits/stdc++.h>
using namespace std;

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

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t = 1;
    while (t--) {
        int n, m;
        cin >> n >> m;

        function<bool(int, int)> inbound = [&](int x, int y) {
            return x >= 0 && y < m && y >= 0 && x < n;
        };
        
        vector<vector<char>> g(n, vector<char>(m));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                cin >> g[i][j];
            }
        }
        
     
        function<vector<vector<int>>(int, int)> bfs = [&](int x, int y) {
            vector<vector<int>> dis(n, vector<int>(m, INT_MAX));
            vector<vector<bool>> vis(n, vector<bool>(m, false));
            vector<pair<int, int>> p;
            queue<pair<int, int>> q;
            
            q.push(make_pair(x, y));
            vis[x][y] = true;
            
            while (!q.empty()) {
                pair<int, int> curr = q.front();
                q.pop();
                int x_ = curr.first;
                int y_ = curr.second;
                p.push_back(make_pair(x_, y_));
                
                for (int i = 0; i < 4; i++) {
                    int nx = x_ + dx[i];
                    int ny = y_ + dy[i];
                    if (inbound(nx, ny) && !vis[nx][ny] && g[nx][ny] == '.') {
                        vis[nx][ny] = true;
                        q.push(make_pair(nx, ny));
                    }
                }
            }
          
            for (auto& pos : p) {
                int x = pos.first;
                int y = pos.second;
                dis[x][y] = 0;
                q.push(make_pair(x, y));
            }
            
            while (!q.empty()) {
                pair<int, int> curr = q.front();
                q.pop();
                int x_ = curr.first;
                int y_ = curr.second;
                
                for (int i = 0; i < 4; i++) {
                    int nx = x_ + dx[i];
                    int ny = y_ + dy[i];
                    if (inbound(nx, ny) && dis[nx][ny] == INT_MAX) {
                        dis[nx][ny] = dis[x_][y_] + 1;
                        q.push(make_pair(nx, ny));
                    }
                }
            }
            
            return dis;
        };
        
        vector<vector<int>> dis0 = bfs(0, 0);
        vector<vector<int>> dis1 = bfs(n - 1, m - 1);
        
        int ans = INT_MAX;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ans = min(ans, dis0[i][j] + dis1[i][j] - 1);
            }
        }
        
        cout << max(ans, 0) << endl;
    }
    
    return 0;
}