剑指 Offer 13. 机器人的运动范围

地上有一个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。请问该机器人能够到达多少个格子？
示例 1：
输入：m = 2, n = 3, k = 1
输出：3
示例 2：
输入：m = 3, n = 1, k = 0
输出：1
提示：
1 <= n,m <= 100
0 <= k <= 20

一开始我直接遍历了所有的组合，之后只要有符合数位之和大于k的就+1。
后来发现，少考虑了一个条件，如果符合条件的位置是不可达的话，那就算符合了数位之和大于k也没有用了。

因此使用dfs遍历所有可能，若是发现上下左右均不可达，那么就直接返回了。

DFS

class Solution {
    boolean[][] flag;
    int count=0;
    public int movingCount(int m, int n, int k) {
        flag=new boolean[m][n];
        dfs(m,n,0,0,k);
        return count;
    }
    //获取数位之和
    public int getSum(int k){
        int sum=0;
        while(k!=0){
            sum+=k%10;
            k/=10;
        }
        return sum;
    }

    public void dfs(int row,int column,int m,int n,int k){
        if(m>=row||n>=column||m<0||n<0){
            return ;
        }
        int sum=getSum(m)+getSum(n);
        if(sum>k){
            return ;
        }else{
            boolean reachable=false;
            if(!flag[m][n]){
                //看这个点是否可达
                for(int i=-1;i<=1;i+=2){
                    if(n+i>=0&&n+i<column){
                        reachable=reachable||flag[m][n+i];
                    }
                    if(m+i>=0&&m+i<row){
                        reachable=reachable||flag[m+i][n];
                    }
                }
                //（0，0）特殊考虑
                if(reachable||(m==0&&n==0)){
                    count++;
                    //设置已经遍历
                    flag[m][n]=true;
                    //搜索上下左右四个方向
                    dfs(row,column,m-1,n,k);
                    dfs(row,column,m+1,n,k);
                    dfs(row,column,m,n-1,k);
                    dfs(row,column,m,n+1,k);
                }
            }
        }
    }
}

可以发现时间复杂度是O(mn)，空间复杂度是O(mn)
优化：把搜索方向缩减为向下和向右。

BFS

class Solution {
    boolean[][] flag;
    int count=0;
    public int movingCount(int m, int n, int k) {
        flag=new boolean[m][n];
        Queue<Pos> queue=new LinkedList<>();
        queue.offer(new Pos(0,0));
        //若是队列非空，那么遍历
        while(!queue.isEmpty()){
            Pos temp=queue.poll();
            int sum=getSum(temp.x)+getSum(temp.y);
            if(sum>k||temp.x>=m||temp.y>=n||temp.x<0||temp.y<0){
                continue;
            }
            //若是没有访问过
            if(!flag[temp.x][temp.y]){
                flag[temp.x][temp.y]=true;
                count++;
                //把它可以到达的点加入队列
                queue.offer(new Pos(temp.x,temp.y+1));
                queue.offer(new Pos(temp.x+1,temp.y));
            }
        }
        return count;
    }
    //获取数位之和
    public int getSum(int k){
        int sum=0;
        while(k!=0){
            sum+=k%10;
            k/=10;
        }
        return sum;
    }

    static class Pos{
        int x;
        int y;
        Pos(int x,int y){
            this.x=x;
            this.y=y;
        }
    }
}

这个bfs，用的时间和空间竟然比dfs还多，我也是醉了。。

递推

class Solution {
    boolean[][] flag;
    int count=0;
    public int movingCount(int m, int n, int k) {
        flag=new boolean[m][n];
        flag[0][0]=true;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                int sum=getSum(i)+getSum(j);
                if(sum>k||i>=m||j>=n){
                    continue;
                }
                //看上面和右面的格子是否可达
                if(i-1>=0){flag[i][j]=flag[i][j]||flag[i-1][j];}
                if(j-1>=0){flag[i][j]=flag[i][j]||flag[i][j-1];}
                //若是可达，那么格子数+1
                count=flag[i][j]?count+1:count;
            }
        }
        return count;
    }
    //获取数位之和
    public int getSum(int k){
        int sum=0;
        while(k!=0){
            sum+=k%10;
            k/=10;
        }
        return sum;
    }

}

结果就是我这三种方法写下来，效率最高的竟然是DFS。迷惑。。