为什么对于这个Leetcode问题（单词搜索），我的第一个解决方案比第二个解决方案运行得慢？

Question

以下是对不熟悉此问题的人的问题声明：

给定一个二维板和一个单词，找出这个单词是否存在于网格中。这个词可以由顺序相邻单元格的字母构成，其中“相邻”单元格是那些水平或垂直相邻的单元格。同一个字母单元格不能使用不止一次。

public boolean exist(char[][] board, String word) {
        if (word == null || word.length() == 0) return true;
        if (board == null || board.length == 0 || board[0] == null) return false;
        if (word.length() > board.length * board[0].length) return false;
        char[] w = word.toCharArray();
        char a = w[0];
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j] == a && DFS(board,w,i,j,0)) return true;
            }
        }
        return false;
    }

public boolean DFS(char[][] board, char[] word, int i, int j, int idx) {
        if (idx == word.length) return true;
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length ||
           board[i][j] != word[idx]) return false;
        board[i][j] = '@';
        int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
        for (int[] d : dirs) {
            if (DFS(board,word,i+d[0],j+d[1],idx+1)) return true;
        }
        board[i][j] = word[idx];
        return false;
    }

解决方案2

public boolean DFS(char[][] board, char[] word, int i, int j, int idx) {
        if (idx == word.length) return true;
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length ||
           board[i][j] != word[idx]) return false;
        board[i][j] = '@';
        boolean found = false;
        found = DFS(board,word,i-1,j,idx+1) || DFS(board,word,i+1,j,idx+1) ||
            DFS(board,word,i,j-1,idx+1) || DFS(board,word,i,j+1,idx+1);
        board[i][j] = word[idx];
        return found;
    }

现在，据我所知，随着Java的短路，dfs()的两个版本都应该停止探索其他路径，如果任何子问题返回true。事实上，我可以评估的两个版本之间唯一的操作差异是，如果找到解决方案，第一个版本不需要重置董事会（没有@字符指示访问位置的原始形式），而第二个版本需要重置董事会。

所以根据我的理解，如果有的话，第二个解决方案应该比第一个慢。但很明显，我错了：解决方案一运行8毫秒，而解决方案二运行3毫秒。

Answer 1

jit编译器比你聪明。第二个版本的内联代码更简单（4个版本），而不是1个，它可以反编译并重新编译几次。我猜。