13_剑指offer_机器人的运动范围

思路一：广度优先搜索，借助一个辅助队列

class Solution {
    boolean[][] flag;

    public int movingCount(int m, int n, int k) {
        flag = new boolean[m][n];
        // 用bfs的方法来搜寻。
        LinkedList<int[]> list = new LinkedList();
        list.add(new int[]{0, 0});
        flag[0][0] = true;
        int x;
        int y;
        int res = 1;
        while (!list.isEmpty()) {
            int[] tmp = list.remove();
            x = tmp[0];
            y = tmp[1];
            // 向下一个结点
            if (x + 1 < m && !flag[x + 1][y] && compare(x + 1, y, k)) {
                res++;
                list.add(new int[]{x + 1, y});
                flag[x + 1][y] = true;
            }
            if (y + 1 < n && !flag[x][y + 1] && compare(x, y + 1, k)) {
                res++;
                list.add(new int[]{x, y + 1});
                flag[x][y + 1] = true;
            }
        }
        return res;
    }

    public boolean compare(int x, int y, int k) {
        int tmp = x % 10 + x / 10 % 10 + y % 10 + y / 10 % 10;
        return tmp <= k;
    }
}

思路二：深度优先遍历，速度更快。

class Solution {
    boolean[][] flag;
    int k;
    int m;
    int n;
    int res;

    public int movingCount(int m, int n, int k) {
        // 用深度优先搜索的方法，dfs
        this.k = k;
        flag = new boolean[m][n];
        this.m = m;
        this.n = n;
        search(0, 0);
        return res;

    }

    public void search(int x, int y) {
        if (x >= m || y >= n) return;
        if (!flag[x][y] && compare(x, y, k)) {
            res++;
            flag[x][y] = true;
            search(x + 1, y);
            search(x, y + 1);
        }
    }

    public boolean compare(int x, int y, int k) {
        int tmp = x % 10 + x / 10 % 10 + y % 10 + y / 10 % 10;
        return tmp <= k;
    }
}