7、13、34

最新推荐文章于 2024-10-18 23:40:34 发布

保护眼睛

最新推荐文章于 2024-10-18 23:40:34 发布

阅读量109

点赞数 1

分类专栏：搜索剑指offer 文章标签： dfs 算法

本文链接：https://blog.csdn.net/qq_45859087/article/details/119429328

版权

搜索同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

剑指offer

5 篇文章 0 订阅

订阅专栏

本文解析了剑指Offer中的三个技术问题：重建二叉树（通过前序和中序遍历），机器人的运动范围（动态规划求解），以及查找二叉树中和为特定值的路径（深度优先搜索）。通过实例演示，深入理解这些算法在实际编程中的应用。

摘要由CSDN通过智能技术生成

剑指offer

剑指 Offer 07. 重建二叉树

class Solution7 {
    public int pIndex;

    public TreeNode buildTreeChild(int[] preorder, int[] inorder, int begin, int end) {
        if (begin > end)
            return null;
        TreeNode root = new TreeNode(preorder[pIndex]);
        int index = getIndex(inorder, begin, end, preorder[pIndex]);
        pIndex++;
        root.left = buildTreeChild(preorder, inorder, begin, index - 1);
        root.right = buildTreeChild(preorder, inorder, index + 1, end);

        return root;
    }

    public int getIndex(int[] inorder, int begin, int end, int key) {
        for (int i = begin; i <= end; i++) {
            if (inorder[i] == key) {
                return i;
            }
        }
        return -1;
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null || preorder.length == 0 || inorder == null || inorder.length == 0)
            return null;
        return buildTreeChild(preorder, inorder, 0, inorder.length - 1);
    }
}

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

class Solution13 {
    public static void main(String[] args) {
        System.out.println(movingCount(2, 3, 1));
    }

    static boolean[][] visited;

    public static int movingCount(int m, int n, int k) {
        visited = new boolean[m][n];
        return dfs(0, 0, k, m, n);
    }

    private static int dfs(int i, int j, int k, int m, int n) {
        if (i >= m || j >= n || getCountSum(i) + getCountSum(j) > k || visited[i][j]) {
            return 0;
        }
        visited[i][j] = true;
        return 1 + dfs(i + 1, j, k, m, n) + dfs(i, j + 1, k, m, n);
    }

    private static int getCountSum(int num) {
        int sum = 0;
        while (num != 0) {
            sum += num % 10;
            num = num / 10;
        }
        return sum;
    }
}

剑指 Offer 34. 二叉树中和为某一值的路径

class Solution34 {
    List<List<Integer>> res = new LinkedList<>();
    Deque<Integer> path = new LinkedList<>();

    public List<List<Integer>> pathSum(TreeNode root, int target) {
        dfs(root, target);
        return res;
    }

    public void dfs(TreeNode root, int target) {
        if (root == null)
            return;
        path.offer(root.val);
        target -= root.val;

        if (target == 0 && root.right == null && root.left == null) {
            res.add(new LinkedList<>(path));
        }
        dfs(root.left, target);
        dfs(root.right, target);
        path.removeLast();
    }
}