2022.4.29 剑指12，13，34，54

学习剑指offer 第14天，15天

12 矩阵中的路径

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

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

• 解答

   boolean[][] record;
    public boolean exist(char[][] board, String word) {
        if(word.length() == 0) return false;
        record = new boolean[board.length][board[0].length];
        //寻找起点
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board[0].length; j++){
               if(backtracking(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }

    public boolean backtracking(char[][] board, String word, int beginx, int beginy, int index){
        //注意条件判断的顺序：先判断是否遍历完word，再判断是否数组越界
        if(index >= word.length()) return true;
        if(beginx >= board.length || beginy >= board[0].length || beginx < 0 || beginy < 0) return false;
        if(record[beginx][beginy]) return false;
        //上下左右遍历
        if(board[beginx][beginy] == word.charAt(index)){
            record[beginx][beginy] = true;
            boolean left = backtracking(board, word, beginx - 1, beginy, index + 1);
            boolean right = backtracking(board, word, beginx + 1, beginy, index + 1);
            boolean up = backtracking(board, word, beginx, beginy - 1, index + 1);
            boolean down = backtracking(board, word, beginx, beginy + 1, index + 1);
            if(left || right || up || down) return true;
            record[beginx][beginy] = false;
        }
        return false;
    }

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

 boolean[][] record;
    int sum = 0;
    public int movingCount(int m, int n, int k) {
        record = new boolean[m][n];
        submovingcount(0, 0, k);
        return sum;
    }

    public void submovingcount(int m, int n, int k){
        if(m >= record.length || n >= record[0].length || m < 0 || n <0 || record[m][n]) return;
        if(sumnum(m) + sumnum(n) <= k){
            record[m][n] = true;
            sum++;
            submovingcount(m + 1, n, k);
            submovingcount(m - 1, n, k);
            submovingcount(m, n + 1, k);
            submovingcount(m, n - 1, k);
        } 
    }

    public int sumnum(int num){
        int sum2 = 0;
        while(num / 10 != 0){
            sum2 += num % 10;
            num = num / 10;
        }
        sum2 += num;
        return sum2;
    }

34 二叉树中和为某一值的路径

• 题目描述
  给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

• 解答

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> element = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        if(root == null) return result;
        backTracking(root, target, 0);
        return result;
    }
    
    public void backTracking(TreeNode root, int target, int cur){
        if(root.left == null && root.right == null){
            if(cur + root.val == target){
                element.add(root.val);
                result.add(new ArrayList(element));
                element.remove(element.size() - 1);
            } 
            return;
        }
        //注意：没有说是全正数
        //if(cur + root.val > target) return;
        element.add(root.val);
        if(root.left != null) backTracking(root.left, target, cur + root.val);
        if(root.right != null) backTracking(root.right, target, cur + root.val);
        element.remove(element.size() - 1);
    }
}

54 二叉搜索树的第k大节点

⚠️：二叉搜索树：中序遍历为递增顺序；如果先看右节点，再看左节点就是递减顺序

int count = 0;
    int result = 0;
    public int kthLargest(TreeNode root, int k) {
        in_order(root, k);
        return result;
    }
    //逆着进行中序遍历:先看右节点，在看左节点
    public void in_order(TreeNode root, int k){
        if(root.right != null) in_order(root.right, k);
        //负责计数，到k就输出
        count++;
        if(count == k){
            result = root.val;
            return;
        }
        if(root.left != null) in_order(root.left, k);
    }