《剑指offer》之回溯法专题

　　回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。

　　我个人觉得回溯法可以理解为深度优先遍历或者类似树的先序遍历。

（一）.矩阵中的路径

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

例如 a b c e s f c s a d e e
矩阵中包含一条字符串”bccced”的路径，但是矩阵中不包含”abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
        /**
        1.判断矩阵中是否含有该字符串的路径； 回溯法：感觉这道题有深度优先遍历的意思；
          又因为是矩阵，所以又像广度优先遍历；
        **/
        //边界条件判断
        if(matrix==null||rows<1||cols<1||str==null){
            return false;
        }
         if(matrix.length!=rows*cols)return false;
        //新建一个判断矩阵
        boolean[] temp = new boolean[rows*cols];
        //通过双重遍历找到字符串中第一个字符在矩阵中的位置；
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(has(matrix,rows,cols,str,temp,i,j,0)){
                    return true;
                }
            }
        }

        return false;

    }


    public boolean has(char[] matrix,int rows,int cols,char[] str,boolean[] temp,int i,int j,int k){

        //如果k超过字符串的长度了，直接返回true，不再遍历
        if(k==str.length){
            return true;
        }
        //实行的原则是：左右边界可以通过，上下边界无法遍历；
        if(j==cols){
            i++;
            j=0;
        }
        if(j==-1){
            i--;
            j=cols-1;
        }
        if(i<0||i>=rows||temp[i*cols+j]==true||matrix[i*cols+j]!=str[k])return false;
        temp[i*cols+j]=true;
        //对matrix[i*cols+j]的字符上下左右遍历； 用|| 表示四个只要有一个为true即总的为true；回溯法的核心
        boolean sign = has(matrix,rows,cols,str,temp,i-1,j,k+1)||
            has(matrix,rows,cols,str,temp,i,j+1,k+1)||
            has(matrix,rows,cols,str,temp,i+1,j,k+1)||
            has(matrix,rows,cols,str,temp,i,j-1,k+1);
        //递归往回遍历时，把遍历过的矩阵地址重新变成可以遍历
        temp[i*cols+j]=false;

        return sign;

    }
    }

---

（二）.机器人的运动范围

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

public class Solution {

    //记录到达的格子数
    int count = 0;
    public int movingCount(int threshold, int rows, int cols)
    {
        //边界条件判断
        if(rows<=0||cols<=0){
            return 0;
        }
        //建立一个判断矩阵
        boolean[] temp=new boolean[rows*cols];

        moving(rows,cols,temp,0,0,threshold);

        return count;
    }

    public void moving(int rows,int cols,boolean[] temp,int i,int j,int k){

        if(check(rows,cols,i,j,k,temp)){
            count++;
            temp[i*cols+j]=true;
        }else{
            return;
        }
        moving(rows,cols,temp,i-1,j,k);
        moving(rows,cols,temp,i,j+1,k);
        moving(rows,cols,temp,i+1,j,k);
        moving(rows,cols,temp,i,j-1,k);


    }

    //判断机器人能否进入坐标为（i,j）的位置
    public boolean check(int rows,int cols,int i,int j,int k,boolean[] temp){

        if(i<0||i>=rows||j<0||j>=cols||temp[i*cols+j]==true||((getDigitSum(i)+getDigitSum(j))>k)){
            return false;
        }

        return true;

    }

    //得到一个数的数位之和
    public int getDigitSum(int num){

        int sum=0;
        while(num>0){

          sum+=num%10;
          num/=10;
        }

        return sum;
    }  
}