以下递归代码的时间复杂度是多少?

不确定它是否相关，但我试图解决的问题是

~~~~~~~~~~~~~~~与所有建筑物的距离最短~~

~~~~~~~~~~~~~~~你想在一块空地上建造一所房子，在最短的距离内到达所有建筑物。您只能向上、向下、向左和向右移动。您将获得一个值为 0、1 或 2 的 2D 网格，其中：

每个0都标记着一块空地，您可以自由通过。 每个 1 标记一个您无法通过的建筑物。 每个 2 标记一个您无法通过的障碍。

找到与空地的最小距离，可以进入所有建筑物 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

尽管我的解决方案在小输入上正常工作，但由于时间复杂度大，较大的输入超时。

但是，我不确定此解决方案的确切时间复杂度，并希望正确了解此解决方案的时间复杂度，以便我可以在可能的情况下尝试改进它。

我很确定外循环的时间复杂度是 O(MN((M 是行的总数，N 是总行数(，因为我们在网格的所有位置上循环，但我不确定的是递归 shortDist 方法的时间复杂度。它是否也是 O(MN(，因为在最坏的情况下它会触及网格的每个位置，因此该解决方案的总时间复杂度将是 O(M^2 * N^2( 还是其他什么，如果是这样，如果有人可以解释一下我会很棒。

我的解决方案是

class Solution {
public:
int shortestDistance(vector<vector<int>>& grid) {
vector<std::pair<int,int>> dir = {{-1,0}, {1,0}, {0,-1}, {0,1}};
// pair(row, col) -> distance
map<std::pair<int,int>, int> cache;
vector<vector<bool>> visited(grid.size(), vector<bool>(grid[0].size(), false)); // to check if we have already visited that location on the grid
int minDist = INT_MAX;
int maxCount =0;
// Finding number of 1's
for(int i =0; i< grid.size(); i++)
{
for(int y =0; y < grid[0].size(); y++)
{
if(grid[i][y] == 1)
{
maxCount++;
}
}
}
// For each 0 find the distance of each 1's and their count
// if the count of 1's is less than the number of 1's in the
// grid that grid position is not an acceptable pos
for(int i =0; i< grid.size(); i++)
{
for(int y =0; y < grid[0].size(); y++)
{
if(grid[i][y] == 0)
{
shortDist(grid, cache, dir, visited, i, y, 0);
int dist =0;
int count = cache.size();// number of 1's
if(count == maxCount)
{
// if we are here it implies that the empty land space have path to all the buildings
for(auto iter = cache.begin(); iter != cache.end(); iter++)
{
dist += iter->second;
}
if(dist < minDist)
{
minDist = dist;
}
}
cache.clear();
}       
}
}
return minDist == INT_MAX ? -1 : minDist;
}
void shortDist(vector<vector<int>>& grid, map<std::pair<int,int>, int>& cache, vector<std::pair<int,int>>& dir, vector<vector<bool>>& visited, int row, int col, int dist)
{
if(row < 0 || col < 0 || row >= grid.size() || col >= grid[0].size())
{
return;
}
if(grid[row][col] == 2)
{
return;
}
if(grid[row][col] == 1)
{
auto found = cache.find(make_pair(row, col));
if(found == cache.end())
{
cache[(make_pair(row, col))] = dist;
}
else
{
found->second = min(found->second, dist);
}
return;
}
if(visited[row][col])
{
return;
}
visited[row][col] = true;
for(int i =0; i < dir.size(); i++)
{
int newRow = row + dir[i].first;
int newCol = col + dir[i].second;
shortDist(grid, cache, dir, visited, newRow, newCol, dist+1);
}
visited[row][col] = false;
}
};