bobo老师，我用两种方法做了LC 1102 Path with maximum minimum value这个题目: Dijkstra和二分+DFS。

我的时间复杂度分析是Dijkstra应该比DFS+二分要快，但是结果是二分+DFS要比Dijkstra快一倍，所以想请教您，是否分析有误？

首先，Dijkstra算法的时间复杂度是 M*N*log(M*N)，其中M和N是grid矩阵的行数和列数，范围是[0, 100]。

而DFS + 二分的时间复杂度是 log(C)*M*N，其中C是二分搜索的范围，即矩阵的值的范围[0, 10^9]。

在Dijkstra算法中，M*N最大是10^4。所以比较log的order，Dijkstra算法应该更优秀。但是我的代码显示 DFS+二分更好，甚至速度上beat了98%。

所以想请教您，时间复杂度分析是否正确？如果正确的话，如何解释这种差异呢？谢谢老师！

代码如下

class Solution { 
    private int[] dx = {1, 0, -1, 0}; 
    private int[] dy = {0, 1, 0, -1}; 
    public int maximumMinimumPath(int[][] grid) { 
    
        int m = grid.length; 
        int n = grid[0].length; 
        boolean[][] visited = new boolean[m][n]; 
        Queue<int[]> pq = new PriorityQueue<>((a, b) -> b[1] - a[1]); 
        pq.offer(new int[]{0, grid[0][0]}); 
        while (!pq.isEmpty()) { 
            int x = pq.peek()[0] / n; 
            int y = pq.peek()[0] % n; 
            int val = pq.peek()[1]; 
            pq.poll(); 
            
            if (x == m - 1 && y == n - 1) 
                return val; 
            
            if (visited[x][y]) 
                continue; 
            
            visited[x][y] = true; 
            
            for (int k = 0; k < 4; k++) { 
                int nx = x + dx[k]; 
                int ny = y + dy[k]; 
                if (!inArea(nx, ny, grid) || visited[nx][ny]) 
                    continue; 
                
                pq.offer(new int[]{nx * n + ny, Math.min(val, grid[nx][ny])}); 
                } 
         } 
         return -1; 
    } 
  private boolean inArea(int x, int y, int[][] grid) { 
      return x >= 0 && x < grid.length && y >= 0 && y < grid[0].length; 
  }
  
 }

DFS + Binary Search 

class Solution {
    private int[] dx = {1, 0, -1, 0};
    private int[] dy = {0, 1, 0, -1};
    
    public int maximumMinimumPath(int[][] grid) {
       
        int l = 0, r = 1000000000;
        int m = grid.length;
        int n = grid[0].length;
        
        boolean[][] visited;
        
        while (l < r) {
            int mid = l + (r - l + 1) / 2;
            
            visited = new boolean[m][n];
            
            if (hasPath(0, 0, mid, grid, visited))
                l = mid;
            else
                r = mid - 1;
        }
        
        return l;
    }
    
    private boolean hasPath(int x, int y, int score, int[][] grid, boolean[][] visited) {
        
        if (grid[x][y] < score)
            return false;
        
        visited[x][y] = true;
     
        int m = grid.length;
        int n = grid[0].length;
        
        for (int k = 0; k < 4; k++) {
            int nx = x + dx[k];
            int ny = y + dy[k];
            
            if (!inArea(nx, ny, grid) || visited[nx][ny] || grid[nx][ny] < score)
                continue;
            
            if (nx == m - 1 && ny == n - 1)
                return true;
            
            if (hasPath(nx, ny, score, grid, visited))
                return true;
        }
        
        return false;
        
    }
    
  
    
    private boolean inArea(int x, int y, int[][] grid) {
        return x >= 0 && x < grid.length && y >= 0 && y < grid[0].length;
    } 
}