剑指offer刷题-机器人的运动范围（回溯法）+矩阵中的路径

机器人的运动范围

题目描述

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

思路：

先判断机器人能否进入(i,j)，再判断周围4个格子。需要另外一个矩阵来存储是否已经验证过这个方格。

public class Solution {
    public int movingCount(int threshold, int rows, int cols)
    {
        if(threshold == 0)
            return 1;
        if(threshold < 0 || rows <= 0 || cols <=0)
            return 0;
        //矩阵用来记录是否已经访问过该方格
        boolean[][] visited = new boolean[rows][cols];
        return countingsteps(threshold,rows,cols,0,0,visited);
    }
    private int countingsteps(int threshold,int rows,int cols,int row,int col,
                              boolean[][] visited)
    {
    	//进行访问的条件：1、是否位于矩阵内；2、是否已经访问过；3、数位之和是否大于阈值
        if(row>=rows || col>=cols || row<0 || col <0 || visited[row][col] || 
           sum(row)+sum(col)>threshold)
            return 0;
        visited[row][col] = true;
        //再判断周围四个方格
        return 1+countingsteps(threshold,rows,cols,row-1,col,visited)+
            countingsteps(threshold,rows,cols,row+1,col,visited)+
            countingsteps(threshold,rows,cols,row,col-1,visited)+
            countingsteps(threshold,rows,cols,row,col+1,visited);
    }
    //计算数位之和
    private int sum(int num)
    {
        int count =0;
        while(num !=0)
        {
            count += num % 10;
            num = num /10;
        }
        return count;
    }
}

矩阵中的路径

题目描述

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

矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

思路：

这是一个可以用回溯法解决的典型问题。

首先，遍历这个矩阵，找到与字符串str中第一个字符相同的矩阵元素ch。然后遍历ch的上下左右四个字符，如果有和字符串str中下一个字符相同的，就把那个字符当作下一个字符（下一次遍历的起点），如果没有，就需要回退到上一个字符，然后重新遍历。

为了避免路径重叠，需要一个辅助矩阵来记录路径情况。下面代码中，当矩阵坐标为（row，col）的格子和路径字符串中下标为pathLength的字符一样时，从4个相邻的格子（row，col-1）、（row-1，col）、（row，col+1）以及（row+1，col）中去定位路径字符串中下标为pathLength+1的字符。如果4个相邻的格子都没有匹配字符串中下标为pathLength+1的字符，表明当前路径字符串中下标为pathLength的字符在矩阵中的定位不正确，我们需要回到前一个字符串（pathLength-1），然后重新定位。一直重复这个过程，直到路径字符串上所有字符都在矩阵中找到格式的位置（此时pathLength] ==str.length-1）。

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 i=0; i<rows; i++)
        {
            for(int j= 0; j<cols; j++)
            {
            	//先找到字符串的第一个字符所在位置
                if(haspathcore(matrix,rows,cols,i,j,str,pathlength,visited))
                {
                    return true;
                }
            }
        }
        return false;
    }
    private boolean haspathcore(char[] matrix,int rows,int cols, int row, int col,
                                char[] str,int pathlength,boolean[][] visited)
    {
        if(row < 0|| col<0 || row >= rows || col >=cols || visited[row][col] || 
           pathlength >= str.length || matrix[row*cols +col]!=str[pathlength])
           //若1、超出矩阵范围；2、已访问过；3、超出字符串索引；4、当前位置字符不相等
            return false;
        //若此时是字符串最后一个元素，则找完返回true
        if(pathlength == str.length-1)
            return true;
        //当前矩阵坐标为（row，col）的格子和路径字符串中下标为pathLength的字符一样，则
        //从4个相邻的格子row，col-1）、（row-1，col）、（row，col+1）以及
        //（row+1，col）中去定位路径字符串中下标为pathLength+1的字符
        visited[row][col] = true;
        pathlength++;
        boolean hasnext =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);
        //如果4个相邻的格子都没有匹配字符串中下标为pathLength+1的字符，表明当前路径
        //字符串中下标为pathLength的字符在矩阵中的定位不正确，我们需要回到前一个字符串
        //（pathLength-1），然后重新定位
        if(!hasnext)
        {
            pathlength--;
            visited[row][col] = false;
            return false;
        }
        else
            return true;
    }
}

回溯法（经典算法后续补充呀呀呀）

是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

在回溯法中，每次扩大当前部分解时，都面临一个可选的状态集合，新的部分解就通过在该集合中选择构造而成。这样的状态集合，其结构是一棵多叉树，每个树结点代表一个可能的部分解，它的儿子是在它的基础上生成的其他部分解。树根为初始状态，这样的状态集合称为状态空间树。

回溯法对任一解的生成，一般都采用逐步扩大解的方式。每前进一步，都试图在当前部分解的基础上扩大该部分解。它在问题的状态空间树中，从开始结点（根结点）出发，以深度优先策略搜索整个状态空间。这个开始结点成为活结点，同时也成为当前的扩展结点。在当前扩展结点处，搜索向纵深方向移至一个新结点。这个新结点成为新的活结点，并成为当前扩展结点。如果在当前扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的活结点处，并使这个活结点成为当前扩展结点。回溯法以这种工作方式递归地在状态空间中搜索，直到找到所要求的解或解空间中已无活结点时为止。