剑指offer 回溯

在牛客网上做了一个月，终于把《剑指offer》的67道题大致刷了一篇，还有一部分没做出来，现在到了二刷总结的时候了。

今天给大家带来最后两道题，属于典型的回溯法问题，虽然我在做的时候AC了，但还是很有必要总结下，看了下《剑指offer》书上的题解，再一次证明了我的代码写的多烂，哈哈哈。

下面直接进入正题吧。

回溯法和图的深度优先遍历很类似，先递归的去试探，当此时走不下去了，回退到上一步的状态，往另一个方向进行试探。

题目描述1

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

该题很明显可以使用回溯法进行试探，当找到了一条路径后，程序就可以结束了，并返回成功，只有当所有的路径都尝试了还是没有找到一条路径，则表明失败。这里需要注意的是，同一个路径中，不能同时访问同一个格子，所以我们必须在试探的过程中，记录哪些格子已经被访问了。

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
       if(matrix == null || rows < 1 || cols < 1 || str == null){
           return false;
       }
        boolean[] visited = new boolean[rows * cols];  // 格子访问标志数组
        int pathLength = 0;   // 当前处于第几步
        for(int row = 0; row < rows; row++){
            for(int col = 0; col < cols; col++){
                if(hasPathCore(matrix, rows, cols, row, col, str, pathLength, visited)){
                    return true;
                }
            }
        }
        return false;
    }
    
    public boolean hasPathCore(char[] matrix, int rows, int cols, int row, int col, char[] str, int pathLength, boolean[] visited){
        if(pathLength == str.length){  // 找到了一条可行的路径
            return true;
        }
        boolean hasPath = false;
        if(row >= 0 && row < rows && col >= 0 && col < cols && str[pathLength] == matrix[row * cols + col] && visited[row * cols + col] == false){
            pathLength ++;
            visited[row * cols + col] = true;  // 设置当前格子被访问
            // 四个方向试探
            hasPath = hasPathCore(matrix, rows, cols, row-1,col,str,pathLength, visited)
                      || hasPathCore(matrix, rows, cols, row+1,col,str,pathLength, visited)
                      || hasPathCore(matrix, rows, cols, row,col+1,str,pathLength, visited)
                      || hasPathCore(matrix, rows, cols, row,col-1,str,pathLength, visited);
            if(hasPath == false){  // 当前走不下去，回退到上一步，需要恢复一些信息
                pathLength --;
                visited[row * cols + col] = false;
            }
        }
        return hasPath;
    }
}

题目描述2

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

该问题的关键是，有些格子虽然满足条件（行坐标和列坐标的数位之和不大于k），但它被不满足条件的格子包围了，这样这个格子就走不到了。

回溯法解决该问题的思想就是从（0，0）开始试探，看能走到多少个格子。

public class Solution {
    public int movingCount(int threshold, int rows, int cols)
{
        if(threshold < 0 || rows < 1 || cols < 1){
            return 0;
        }
        // 格子访问标志数组
        // visited[i][j] = false: (i,j)可以被访问
        // visited[i][j] = true: (i,j)已经被访问，这一步就不能在走了
        boolean[][] visited = new boolean[rows][cols];
        for(int row = 0; row < rows; row ++){
            for(int col = 0; col < cols; col++){
                visited[row][col] = judge(row,col, threshold);
            }
        }
        return movingCountCore(visited, rows, cols, 0, 0);
    }
    
    public int movingCountCore(boolean[][] visited, int rows, int cols, int row, int col){
        int count = 0;
        if(row >= 0 && row < rows && col >= 0 && col < cols && visited[row][col] == false){
            count ++;
            visited[row][col] = true;
            // 四个方向试探
            count += movingCountCore(visited, rows, cols, row-1, col)
                     + movingCountCore(visited, rows, cols, row+1, col)
                     + movingCountCore(visited, rows, cols, row, col-1)
                     + movingCountCore(visited, rows, cols, row, col+1);
        }
        return count;
    }
    
    public boolean judge(int row, int col, int threshold){
        int sum = 0;
        while(row != 0){
            sum += row % 10;
            row = row / 10;
        }
        while(col != 0){
            sum += col % 10;
            col = col / 10;
        }
        return sum > threshold;
    }
}