剑指Offer——回溯法（矩阵中的路径，机器人的运动范围）

回溯法可以看做暴力法的升级版。从解决问题的每一步的所有可能选择里系统选择一个可行的解决方案。这个方法非常适合多个步骤组成的问题，并且每个步骤有多个选项。

可以形象的用树状结构表示。在某一步有n个可能的选项，那么该步骤可以看做是树状结构的一个节点，每个选项都看作是树中节点的连接线，经过这些连接线到达该节点的n个子节点，树的叶节点对应终结状态，如果叶节点的状态满足题目的约束条件，就找到了一个可行的解决方案。如果不满足，就回溯到上一个节点继续尝试其他选项，如果上一节点的所有可能的选项都被选择，还是不满足约束条件的终结状态，则再次回到上一个节点。如果所有节点的所有选项都已经尝试过仍然不能到达满足约束条件的终结状态，则问题无解。

题目一：请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。

方法：首先在矩阵中随意选取一个格子作为路径的起点，假设路径中某个格子的字符为ch,并且这个格子将对应路径中第i个字符。如果路径中第i个字符不是ch,这个格子不可能处于路径第i个位置。如果是的话，则到相邻位置上寻找路径上的第i+1个字符。除了边界的四个格子，其他格子都有四个相邻的格子。重复这个过程，直到路径上所有字符都在矩阵中找到位置。

由于题目要求不能重复进入矩阵的格子，所以还需要定义一个数组，来表示路径是否已经进入每个格子。

public class Solution {
    public int[][] visited;
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
        //为了处理方便，首先先将字符数组转换为二维数组
        visited=new int[rows][cols];
        char[][] m=new char[rows][cols];
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                m[i][j]=matrix[i*cols+j];
            }
        }
        //因为是随机探寻，所以是用for循环来寻找
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(find(m,rows,cols,i,j,0,str)){
                    return true;
                }
            }
        }
        return false;
    }
    
    
    public boolean find(char[][] m,int rows,int cols,int row,int col,int length,char[] str){
        if(length>=str.length){
            return true;
        }
        //如果寻找的行列大小不满足条件返回0
        //如果这个格子的字符不是字符串对应位置的字符，也返回0
        //访问过也返回0
        if(row<0 || col<0 || row>=rows || col>=cols || m[row][col]!=str[length] || visited[row][col]==1){
            return false;
        }
        //如果字符相等，访问数组对应位置置为0
        visited[row][col]=1;
        //判断相邻的四个格子
        boolean isFind=find(m,rows,cols,row+1,col,length+1,str) 
               || find(m,rows,cols,row,col+1,length+1,str) 
               || find(m,rows,cols,row,col-1,length+1,str) 
               || find(m,rows,cols,row-1,col,length+1,str);
          //不能重复，记得这个格子不行，记为0  
         visited[row][col]=0;
            return isFind;

    }


}

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

解法：这个方法其实和上面的方法基本一致，也是回溯判断，不过这个能否进入格子是检查坐标位数。还有这个给了开始进入的坐标，不需要for循环。

public class Solution {
    public int movingCount(int threshold, int rows, int cols)
    {
        int[][] visited=new int[rows][cols];
        return find(threshold,rows,cols,0,0,visited);
        
    }
    public int find(int threshold,int rows,int cols,int row,int col,int[][] visited){
        if(row<0 || col<0 || row>=rows || col>=cols || sum(row)+sum(col)>threshold || visited[row][col]==1){
            return 0;
        }
        visited[row][col]=1;
        //因此这个测试是能够到达多少个格子，所以走一步记得要加一
        return 
            1+find(threshold,rows,cols,row+1,col,visited)
            +find(threshold,rows,cols,row,col+1,visited)
            + find(threshold,rows,cols,row-1,col,visited)
            + find(threshold,rows,cols,row,col-1,visited);
    }
    
    public int sum(int i){
        int sum=0;
        while(i>0){
            sum+=i%10;
            i=i/10;
        }
        return sum;
    }
}