剑指13--机器人的运动（DFS和BFS）

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

分析：很典型的BFS和DFS的题目，这里需要注意的是上下左右其实在本题中用右和上就可以完成，因为起始点（0，0）是左上角开始的，所以右和上两个方向就可以遍历整个方格。
这里附上BFS和DFS的模板：

while queue 不空：
    cur = queue.pop()
    for 节点 in cur的所有相邻节点：//这步把所有的点都遍历了，此题会超时，C++不会
        if 该节点有效且未访问过：
            queue.push(该节点)

优化后的BFS，因为最终的答案画出来是一个三角形，所以可以在此优化，减少点的计算，只找有效点的周边点。

queue.add(root初始结点)
boolean[] visit;//用作记录结点被访问过没
 while queue 不空：
    cur = queue.pop()；
        if 该节点无效；
        continue;
     boolean[cur]=true;//说明剩下的都有效，将该节点标记为已访问
     for 找出该结点周围的结点（这里是右边是和上边的）
     queue.push();
     

附上代码：

class Solution {
public int movingCount(int m, int n, int k) {
    //队列保存坐标
    Queue<int[]> queue=new ArrayDeque<>();
    //标记数组
    boolean[][] visited=new boolean[m][n];
    int[][] move={{1,0},{0,1}};
    //广搜
    queue.add(new int[]{0,0});
    int count=0;
    while (!queue.isEmpty()) {
        int[] poll = queue.poll();
       int x=poll[0];
        int y=poll[1];
        if(x >= m || y >= n || k < x%10+x/10+y/10+y%10 || visited[x][y])
        continue;
        count++;
        visited[x][y]=true;
        for(int i=0;i<2;i++){
           int newX=x+move[i][0];
            int newY=y+move[i][1];
            int[] temp={newX,newY};
            queue.add(temp);
        }  
        //向下、向右寻找符合要求的位置入队并标记访问状态
        //不越界 并且 数位和小于等于k 并且 未访问过
        
    }
    return count;
}

}

DFS模板：

void dfs()//参数用来表示状态  
{  
    if(到达终点状态)  
    {  
        ...//根据题意添加  
        return;  
    }  
    if(越界或者是不合法状态)  
        return;  
    if(特殊状态)//剪枝
        return ;
    for(扩展方式)  
    {  
        if(扩展方式所达到状态合法)  
        {  
            修改操作;//根据题意来添加  
            标记；  
            dfs（）；  
            (还原标记)；  
            //是否还原标记根据题意  
            //如果加上（还原标记）就是 回溯法  
        }  
 
    }  
}  

没错，DFS就是这么简单！
附上DFS代码：

class Solution {
    private boolean[][] invisit;//这里需要注意DFS里全局变量的问题
    //因此在全局变量这要把DFS中用的变量设置好，这样才能递归出正确结果
    private int[][] move={{1,0},{0,1}};
      private int M;
    private int N;
    private int res=0;
    public int movingCount(int m, int n, int k) {
      this.invisit=new boolean[m][n];
      this.M = m;
        this.N = n;
      dfs(0,0,k);
      return res;
    }
    public void dfs(int x,int y,int k){
        if(!(x>=0&&y>=0&&x<M&&y<N)||invisit[x][y])
        return;
        if(x%10+x/10+y%10+y/10<=k){
            res++;
            invisit[x][y]=true;
            for(int i=0;i<2;i++){
               int a=x+move[i][0];
                int b=y+move[i][1];
                dfs(a,b,k);
            }
        }
    }
}

完结