求问BFS和DFS的时间复杂度？

LC 200. Number of island
分别用BFS和DFS的递归做的（代码如下）。但是BFS超时，DFS通过了。请问二者的时间复杂度分别是多少，针对这道题，设输入是m*n的矩阵。BFS:O((mn)^2)
因为，外面两层循环为O(mn)，内层每次做BFS也是O(mn), 所以为O((mn)^2)
DFS:O(mn)
标准的递归DFS，点有mn个，边有4mn个，所以O(V+E)即是O(mn)
不知道对不对？
还请大神指点！
BFS:
```
class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty()) return 0;
        int m = grid.size(), n = grid[0].size();
        int count = 0;
        queue<pair<int, int> > q;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(grid[j] == '1'){
                    count++;
                    q.push(make_pair(i, j));
                    //BFS
                    while(!q.empty()){
                        int cur_i = q.front().first;
                        int cur_j = q.front().second;
                        q.pop();
                        grid[cur_i][cur_j] = '2';
                        //up
                        if(cur_i != 0 && grid[cur_i - 1][cur_j] == '1')
                            q.push(make_pair(cur_i - 1, cur_j));
                        //down
                        if(cur_i != m - 1 && grid[cur_i + 1][cur_j] == '1')
                            q.push(make_pair(cur_i + 1, cur_j));
                        //left
                        if(cur_j != 0 && grid[cur_i][cur_j - 1] == '1')
                            q.push(make_pair(cur_i, cur_j - 1));
                        //right
                        if(cur_j != n - 1 && grid[cur_i][cur_j + 1] == '1')
                            q.push(make_pair(cur_i, cur_j + 1));
                    }
                }
            }
        }
        return count;
    }
};

```
DFS:
```
class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty()) return 0;
        int m = grid.size(), n = grid[0].size(), count = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(grid[i][j] == '1'){
                    count++;
                    dfs(grid, i, j);
                }
            }
        }
        return count;
    }
private:
    void dfs(vector<vector<char> >& grid, int i, int j){
        int m = grid.size(), n = grid[0].size();
        grid[i][j] = '2';
        if(i != 0 && grid[i - 1][j] == '1') dfs(grid, i - 1, j);
        if(i != m - 1 && grid[i + 1][j] == '1') dfs(grid, i + 1, j);
        if(j != 0 && grid[i][j - 1] == '1') dfs(grid, i, j - 1);
        if(j != n - 1 && grid[i][j + 1] == '1') dfs(grid, i, j + 1);
    }
};
```[/i][/i][/i]

同问这个时间复杂度。。。BFS和DFS时间复杂度都不太会