剑指Offer14

剑指Offer第十四天

回溯算法（中等）

题1：矩阵中的路径

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

class Solution {
    public boolean exist(char[][] board, String word) {
        //用boolean[][] 用于该节点是否被使用过
        boolean[][] dp = new boolean[board.length][board[0].length];
        char[] chars = word.toCharArray();
        for (int i = 0; i < board.length; i++) {
            for (int i1 = 0; i1 < board[0].length; i1++) {
                if (chars[0] == board[i][i1]) {
                    boolean res = helper(board, dp, i, i1, chars, 0);
                    if (res) {
                        return res;
                    }
                }
            }
        }
        return false;
    }

    public  boolean helper (char[][] board, boolean[][] dp, int i, int j, char[] chars,int wordNum) {
        if (wordNum == chars.length - 1) {
            return true;
        }
        dp[i][j] = true;
        boolean res = false;
        //只有当 1.数据范围不溢出 2.改节点没有使用过 3.值相等的情况下，才满足条件
        if (i + 1 < board.length && !dp[i + 1][j] && chars[wordNum+1] == board[i + 1][j]) {
            res = res || helper(board,dp,i + 1,j,chars,wordNum + 1);
        }
        if (i - 1 >= 0 && !dp[i - 1][j] && chars[wordNum + 1] == board[i - 1][j]) {
            res = res || helper(board,dp,i-1,j,chars,wordNum + 1);
        }
        if (j + 1 < board[0].length && !dp[i][j + 1] && chars[wordNum + 1] == board[i][j + 1]) {
            res = res || helper(board,dp,i,j+1,chars,wordNum + 1);
        }
        if (j - 1 >= 0 && !dp[i][j - 1] && chars[wordNum + 1] == board[i][j - 1]) {
            res = res || helper(board,dp,i,j-1,chars,wordNum + 1);
        }

        dp[i][j] = false;
        wordNum--;
        return res;
    }

}

题2：机器人的运动范围

地上有一个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。请问该机器人能够到达多少个格子？

class Solution {
    public int movingCount(int m, int n, int k) {
        //dp[][]判断节点走没走过
        boolean[][] dp = new boolean[m][n];
        int helper = helper(dp, 0, 0, k);
        return helper;
    }

    private int helper(boolean[][] dp, int a, int b, int k){
        if(sumNum(a) + sumNum(b) > k){
            return 0;
        }
        dp[a][b] = true;
        int res = 1;
        if(a-1 >= 0 && !dp[a-1][b]){
            res += helper(dp,a-1, b, k);
        }
        if(a+1 < dp.length && !dp[a+1][b]){
            res += helper(dp, a+1, b, k);
        }
        if(b-1 >= 0 && !dp[a][b-1]){
            res += helper(dp, a, b-1, k);
        }
        if(b+1 < dp[0].length && !dp[a][b+1]){
            res += helper(dp, a, b+1, k);
        }
        return res;
    }

    private int sumNum(int a) {
        if (a == 100) {
            return 1;
        } else if (a / 10 != 0){
            return (a/10) + (a%10);
        } else{
            return a%10;
        }
    }
}