【LeetCode每日一题合集】2023.9.4-2023.9.10（⭐二叉树的重建&二分答案&拓扑排序）

最新推荐文章于 2024-06-22 22:59:06 发布
最新推荐文章于 2024-06-22 22:59:06 发布
阅读量354 收藏
点赞数
分类专栏： 算法刷题记录 文章标签： leetcode 算法 二叉树 二分 拓扑排序 每日一题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/132657873
版权

文章目录

449. 序列化和反序列化二叉搜索树⭐⭐⭐⭐⭐（二叉树的重建）

https://leetcode.cn/problems/serialize-and-deserialize-bst/?envType=daily-question&envId=2023-09-04

在这里插入图片描述
提示：
树中节点数范围是 [0, 10^4]
0 <= Node.val <= 10^4
题目数据 保证 输入的树是一棵二叉搜索树。

解法

  • 给定一颗二叉树的先序遍历和中序遍历可以恢复这颗二叉树
  • 给定一颗二叉树的后序遍历和中序遍历可以恢复这棵二叉树
  • 由于二叉搜索树的中序遍历是有序的，因此给定一颗二叉树的先序遍历（或后续遍历），相当于有了中序遍历和先序遍历（或后续遍历），因此只要有先序遍历（或后序遍历）就可以恢复二叉搜索树

思路总结：
编码——将二叉搜索树的后序遍历结果保存在列表中，将列表转成字符串。
解码——使用split将列表转成字符串数组，将字符串数组解析到栈中，使用栈重建后序遍历二叉树。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        postOrder(root, list);  // 后序遍历，结果放入list
        String str = list.toString();
        return str.substring(1, str.length() - 1);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.isEmpty()) return null;
        // 这里用", "分割是因为Java的toString方法对列表会生成类似[1, 2, 3]的结果
        String[] arr = data.split(", ");
        // 将String转成int存入栈中
        Deque<Integer> stk = new ArrayDeque<>();
        int len = arr.length;
        for (int i = 0; i < len; ++i) {
            stk.push(Integer.parseInt(arr[i]));
        }
        return construct(Integer.MIN_VALUE, Integer.MAX_VALUE, stk);
    }

    // 后序遍历
    void postOrder(TreeNode root, List<Integer> ls) {
        if (root == null) return;
        postOrder(root.left, ls);
        postOrder(root.right, ls);
        ls.add(root.val);
    }

    TreeNode construct(int lower, int upper, Deque<Integer> stk) {
        if (stk.isEmpty() || stk.peek() < lower || stk.peek() > upper) return null;
        int val = stk.pop();        // 取出最后一个节点作为根节点
        TreeNode root = new TreeNode(val);
        root.right = construct(val, upper, stk);    // 重建右子树
        root.left = construct(lower, val, stk);     // 重建左子树
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// String tree = ser.serialize(root);
// TreeNode ans = deser.deserialize(tree);
// return ans;

相关题目——297. 二叉树的序列化与反序列化⭐⭐⭐⭐⭐

https://leetcode.cn/problems/serialize-and-deserialize-binary-tree/

在这里插入图片描述

提示：
树中结点数在范围 [0, 10^4] 内
-1000 <= Node.val <= 1000

解法——深度优先搜索

https://leetcode.cn/problems/serialize-and-deserialize-binary-tree/solutions/290065/er-cha-shu-de-xu-lie-hua-yu-fan-xu-lie-hua-by-le-2/

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        return enCode(root, "");        // 存储前序遍历的结果
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] arr = data.split(",");
        List<String> ls = new LinkedList<String>(Arrays.asList(arr));
        return deCode(ls);
    }

    // 
    public String enCode(TreeNode root, String str) {
        if (root == null) {
            str += "None,";         // 使用None
        } else {
            str += str.valueOf(root.val) + ",";
            str = enCode(root.left, str);
            str = enCode(root.right, str);
        }
        return str;
    }

    // 前序遍历重建
    public TreeNode deCode(List<String> ls) {
        if (ls.get(0).equals("None")) {
            ls.remove(0);
            return null;
        }

        TreeNode root = new TreeNode(Integer.valueOf(ls.get(0)));
        ls.remove(0);
        root.left = deCode(ls);
        root.right = deCode(ls);
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

总结一下这种题目的套路——
把二叉树用前序遍历或者后序遍历存成字符串，（如果不是搜索树的话需要用 None 表示空节点）。
重建的时候通过 split 将各个节点变成 列表或者数组的形式存储下来，同样按照前序遍历或者后序遍历重建二叉树即可。

2605. 从两个数字数组里生成最小数字

https://leetcode.cn/problems/form-smallest-number-from-two-digit-arrays/description/?envType=daily-question&envId=2023-09-05

在这里插入图片描述

提示：
1 <= nums1.length, nums2.length <= 9
1 <= nums1[i], nums2[i] <= 9
每个数组中，元素 互不相同 。

哈希表分情况讨论

class Solution {
    public int minNumber(int[] nums1, int[] nums2) {
        int ans = 99, a = 10, b = 10;
        Set<Integer> s = new HashSet<>();
        for (int num: nums1) {
            s.add(num);
            a = Math.min(a, num);
        }
        for (int num: nums2) {
            if (s.contains(num)) ans = Math.min(ans, num);
            b = Math.min(b, num);
        }
        // 如果有交集 直接返回
        if (ans != 99) return ans;
        // 没有交集，返回 a * 10 + b
        if (a > b) {
            int t = a;
            a = b;
            b = t;
        }
        return 10 * a + b;
    }
}

位运算表示集合，分情况讨论🐂（用位运算表示集合）

class Solution {
    public int minNumber(int[] nums1, int[] nums2) {
        int mask1 = 0, mask2 = 0;
        for (int x: nums1) mask1 |= 1 << x;
        for (int x: nums2) mask2 |= 1 << x;
        // 检查是否有交集
        int m = mask1 & mask2;
        if (m > 0) return Integer.numberOfTrailingZeros(m);
        // 如果没有交集
        int x = Integer.numberOfTrailingZeros(mask1), y = Integer.numberOfTrailingZeros(mask2);
        return Math.min(x * 10 + y, y * 10 + x);
    }
}

1123. 最深叶节点的最近公共祖先

https://leetcode.cn/problems/lowest-common-ancestor-of-deepest-leaves/?envType=daily-question&envId=2023-09-06

在这里插入图片描述

提示：
树中的节点数将在 [1, 1000] 的范围内。
0 <= Node.val <= 1000
每个节点的值都是 独一无二 的。

解法1——dfs找深度，再往上找公共祖先

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Queue<TreeNode> q = new LinkedList<>();
    Map<TreeNode, TreeNode> m = new HashMap<>();
    int d = 0;

    public TreeNode lcaDeepestLeaves(TreeNode root) {
        dfs(root, 0);
        while (q.size() != 1) {
            int sz = q.size();
            Set<TreeNode> s = new HashSet<>();
            for (int i = 0; i < sz; ++i) {
                s.add(m.get(q.poll()));
            }
            for (TreeNode t: s) {
                q.offer(t);
            }
        }
        return q.poll();
    }

    public void dfs(TreeNode root, int t) {
        if (root.left == null && root.right == null) {
            if (t > d) {
                q.clear();
                d = t;
            }
            if (t == d) q.offer(root);
        }
        else {
            if (root.left != null) {
                m.put(root.left, root);
                dfs(root.left, t + 1);
            }
            if (root.right != null) {
                m.put(root.right, root);
                dfs(root.right, t + 1);
            }
        }
    }
}

解法2——一次dfs🐂（⭐要学习这个思路）

https://leetcode.cn/problems/lowest-common-ancestor-of-deepest-leaves/solutions/488055/liang-chong-si-lu-yi-chong-qian-xu-bian-li-yi-chon/?envType=daily-question&envId=2023-09-06在这里插入图片描述

class Solution {
    TreeNode res = null;	// 答案
    int pre = 0;		// 更新最大深度

    public TreeNode lcaDeepestLeaves(TreeNode root) {
        dfs(root, 1);
        return res;
    }

    int dfs(TreeNode node, int d) {
        if (node == null) return d;
        int l = dfs(node.left, d + 1), r = dfs(node.right, d + 1);
        if (l == r && l >= pre) {
            res = node;
            pre = l;
        }
        return Math.max(l, r);
    }
}

2594. 修车的最少时间

https://leetcode.cn/problems/minimum-time-to-repair-cars/?envType=daily-question&envId=2023-09-07

在这里插入图片描述

提示：
1 <= ranks.length <= 10^5
1 <= ranks[i] <= 100
1 <= cars <= 10^6

解法——二分查找答案（⭐）

class Solution {
    public long repairCars(int[] ranks, int cars) {
        Arrays.sort(ranks);
        long l = ranks[0], r = (long)ranks[0] * cars * cars;
        while (l < r) {
            long mid = l + r >> 1;
            if (check(mid, ranks, cars)) r = mid;
            else l = mid + 1;
        }
        return l;
    }

    public boolean check(long k, int[] ranks, int cars) {
        for (int r: ranks) {
            cars -= Math.floor(Math.sqrt((double)(k / r)));
        }
        return cars <= 0;
    }
}

二分查找优化——使用哈希表统计各个能力人数

能力值相同的人，在 t 分钟内修好的车的个数是一样的。

根据数据范围，ranks 中至多有 100 个不同的数字，我们可以统计 ranks 中每个数字的出现次数，这样每次二分至多循环 100 次。

class Solution {
    public long repairCars(int[] ranks, int cars) {
        int[] cnt = new int[101];
        int minR = ranks[0];
        for (int r: ranks) {
            cnt[r]++;
            minR = Math.min(minR, r);
        }
        long l = 0, r = (long)minR * cars * cars;
        while (l < r) {
            long mid = l + r >> 1;
            if (check(mid, cars, cnt, minR)) r = mid;
            else l = mid + 1;
        }
        return l;
    }

    public boolean check(long k, int cars, int[] cnt, int minR) {
        for (int r = minR; r <= 100; ++r) {
            cars -= Math.floor(Math.sqrt(k / r)) * cnt[r];
        }
        return cars <= 0;
    }
}

2651. 计算列车到站时间（超简单取模题目）

https://leetcode.cn/problems/calculate-delayed-arrival-time/?envType=daily-question&envId=2023-09-08

在这里插入图片描述

提示：
1 <= arrivaltime < 24
1 <= delayedTime <= 24

class Solution {
    public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
        return (arrivalTime + delayedTime) % 24;
    }
}

207. 课程表（拓扑排序）

https://leetcode.cn/problems/course-schedule/?envType=daily-question&envId=2023-09-09

在这里插入图片描述

提示：
1 <= numCourses <= 2000
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对 互不相同

解法1——bfs拓扑排序

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<Integer>[] g = new ArrayList[numCourses];
        Arrays.setAll(g, e -> new ArrayList<>());
        int[] in = new int[numCourses];
        for (int[] p: prerequisites) {
            g[p[0]].add(p[1]);
            in[p[1]]++;
        }
        int cnt = numCourses;
        Queue<Integer> q = new LinkedList<>();
        for (int i = 0; i < numCourses; ++i) {
            if (in[i] == 0) {
                q.offer(i);
                cnt--;
            }
        }

        while (!q.isEmpty()) {
            int cur = q.poll();
            for (int nt: g[cur]) {
                if (--in[nt] == 0) {
                    q.offer(nt);
                    cnt--;
                }
            }
        }
        return cnt == 0;
    }
}

解法2——dfs拓扑排序

class Solution {
    List<Integer>[] g;
    boolean[] st;
    int[] in;
    int sum = 0;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        g = new ArrayList[numCourses];
        Arrays.setAll(g, e -> new ArrayList<Integer>());
        in = new int[numCourses];
        st = new boolean[numCourses];
        for (int[] prerequisity: prerequisites) {
            g[prerequisity[0]].add(prerequisity[1]);
            in[prerequisity[1]]++;
        }
        
        for (int i = 0; i < numCourses; ++i) {
            if (in[i] == 0) {
                dfs(i);
            }
        }

        return sum == numCourses;
    }

    public void dfs(int x) {
        if (st[x]) return;
        ++sum;
        st[x] = true;
        for (int y: g[x]) {
            if (--in[y] == 0) {
                dfs(y);
            }
        }
    }
}

210. 课程表 II（求拓扑序列）

https://leetcode.cn/problems/course-schedule-ii/?envType=daily-question&envId=2023-09-10

在这里插入图片描述
提示：
1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= ai, bi < numCourses
ai != bi
所有[ai, bi] 互不相同

class Solution {
    List<Integer>[] g;
    List<Integer> ans = new ArrayList();
    int[] in;

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        g = new ArrayList[numCourses];
        Arrays.setAll(g, e -> new ArrayList<Integer>());
        in = new int[numCourses];
        for (int[] prerequisity: prerequisites) {
            g[prerequisity[1]].add(prerequisity[0]);
            in[prerequisity[0]]++;
        }
        
        Queue<Integer> q = new LinkedList<Integer>();
        for (int i = 0; i < numCourses; ++i) {
            if (in[i] == 0) {
                q.offer(i);
                ans.add(i);
            }
        }
        while (!q.isEmpty()) {
            int x = q.poll();
            for (int y: g[x]) {
                if (--in[y] == 0) {
                    ans.add(y);
                    q.offer(y);
                }
            } 
        }

        if (ans.size() == numCourses) return ans.stream().mapToInt(Integer::intValue).toArray();
        else return new int[]{};
    }
}
Wei *
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode卡-leetcode:leetcode&amp;每日刷一题（2019.04.01）
07-06
leetcode卡 leetcode leetcode 每日刷一题 （2019.04.01 ~ forever） 9 / 1553 :rocket: helper top-interview-questions problems
coolcao#ccsite#【LeetCode每日一题】33.搜索旋转排序数组1
07-25
3. nums 中的每个值都 独一无二 4. nums 肯定会在某个点上旋转 1. 先找到升序区间 2. 如果元素在升序区间内，直接在升序区间对其进行二分查找
【LeetCode每日一题合集】2023.7.10-2023.7.16（dfs & 换根DP）
小威的博客
07-16 349
由此我们得到： ans(A) = sum(A) + sum(B) + cnt(B);因此，对于根节点root的任意子节点child，ans(child) = ans(root) - cnt(child) + N - cnt(child);将问题拆分：对于两个相邻节点A和B，将树拆分为两个子树，根节点分别为A和B，A节点到其他所有节点的距离和。同理，ans(B) = sum(B) + sum(A) + cnt(A);
【LeetCode每日一题合集】2023.8.14-2023.8.20（⭐切披萨&&3n块披萨）
小威的博客
09-04 312
定义 dfs(c, i, j) 表示把左上角在 (i, j)，右下角在 (m - 1, n - 1) 的子矩阵切 c 刀，每块都至少包含一个苹果的方案数。dp[i][j] 表示考虑 0 ~ i 下标的 slices，购买 j 个最大价值。为方便取模运算，循环中的下标可以从 0 开始，在返回时再加一。有点像 环形打家劫舍 + 最多买卖k次的股票 的结合。
【LeetCode每日一题合集】2023.8.21-2023.8.27（统计点对的数目）
小威的博客
09-04 260
也就是每次记录一下 start，继续用 while 枚举 i。
每日一题2023.9.25|LeetCode1367.二叉树中的链表
weixin_46290302的博客
09-25 192
采用前序遍历的方式从根节点开始遍历二叉树，并在遍历的过程中比较与链表节点的值是否相等，如果当前链表节点的值和树节点的值相等，就在树节点的左右子树寻找下一个链表节点；如果不相等就在树节点的左右子树寻找当前链表节点的值；后来我再次回想这版错误答案的时候，我发现错误之处并非像上述所说的那样，链表的结构不会因为传递的参数而被改变，就像遍历二叉树的时候，树的结构不会因为传递的参数而发生变化。后来我发现，我传递的参数是以指针的形式传递的，如果当前的链表节点的值与树节点的值相等，会做这么一个操作。
【LeetCode每日一题合集】2023.12.11-2023.12.17 （⭐二维前缀和+二维差分 & 珂朵莉树）
小威的博客
12-18 1021
因为先处理了 stk2，可以确保在 stk1 的数据推入 stk2 之前，stk2 中
【LeetCode每日一题合集】2023.8.28-2023.9.3（到家的最少跳跃次数）
小威的博客
09-05 508
通过枚举购买钢笔的数量，计算此时可以购买铅笔的数量，+1即是购买此时数量钢笔时，购买铅笔的方案数。如果不相交，判断新加入的区间是否在当前区间之前，如果是，就先加入答案。遍历一遍之后，如果没有处理过新加入的区间，就说明新区间应该加在最后。将元素排序之后，从小到大依次处理各个数值作为根节点时的二叉树数量。当前区间与要加入的新区间之间的关系只有两种可能：相交或者不相交。一次遍历，遍历的过程中记录上一个 1 或 -1 出现的位置即可。的下标范围内找到最优解，其中 f 是最远进制点的坐标。如果相交，将两者结合即可。
Leetcode每日一题：打家劫舍系列Ⅰ、Ⅱ、Ⅲ、Ⅳ（2023.9.16~2023.9.19 C++）
Cosmoshhhyyy的博客
09-16 407
打家劫舍系列题，包含代码与解析。
2023.9Datawhale_Leetcode_算法入门与数组_学习笔记（一）
dandellion_的博客
09-10 160
凭借不到一个月的Python基础，我将接触Leetcode这个代码在线评测平台，不断刷题以练习编程技能并提高算法能力。这一系列的学习笔记将会在学习期间随着我不断深入的认知而持续修正和更新。
【LeetCode每日一题】【2023/1/15】2293. 极大极小游戏
Wang_Xin_Ling的博客
01-15 730
方法： 1. 双指针
leetcode每日一题在哪-LeetCode-Solutions:我的Leetcode.com解决方案和有用的代码
06-30
每日一题在哪编码_挑战 这是我每天回答 Leetcode 问题的地方。 下面我将为我的每个答案写一个快速解释。 这个 repo 将作为一个地方来跟踪我的问题解决能力以及我的算法交流工作。 ### 2016 年 4 月 11 日星期一 19:...
12-3 LeetCode：226. 翻转二叉树.mp4
05-30
12-3 LeetCode：226. 翻转二叉树.mp4
12-5 LeetCode：101. 对称二叉树.mp4
05-30
12-5 LeetCode：101. 对称二叉树.mp4
LeetCode：经典题之206、92 题解及延伸
最新发布
Chiefavefan
06-22 894
LeeCode经典题之206、92｜反转链表 I 和 II｜类与结构体｜访问修饰符
LeetCode118.杨辉三角 | LeetCode119.杨辉三角Ⅱ
iiiiiankor的博客
06-21 407
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。每一次从当前行j位置开始，从后向前走（否则前面的会被覆盖）在「杨辉三角」中，每个数是它左上方和右上方的数的和。，返回「杨辉三角」的第。就从下标从1的行开始迭代。j位置+=j-1位置的值。求下标为index的行。
LeetCode.41缺失的第一个正数详解
LeoLei8060的博客
06-22 398
首先，遍历数组，对于每个元素，如果它是一个正整数并且它不在它的理想位置（例如数字 iii 应该位于索引i−1），则将它与其理想位置上的元素交换。最后，遍历数组查找第一个非负数的索引，该索引加 1 即为未出现的最小正整数。通过确保所有的正整数均在数组中有一个对应的索引，我们可以通过索引位置来判断一个数是否存在于数组中。再次遍历数组，第一个其索引+1不等于其值的位置，就指示了未出现的最小正整数。首先，我们需要遍历数组，将所有非正整数以及大于数组长度的数替换为一个大于数组长度的值（例如。请你实现时间复杂度为。
力扣454题解：四数相加（java实现简易）
2301_77695569的博客
06-17 721
LeetCode第454题是一个考察数组和哈希表的经典问题。通过这个问题，我们可以加深对双指针技巧和哈希表应用的理解。掌握这个问题的解法，对于解决其他相关问题非常有帮助。
https://leetcode-cn.com/problems/minimum-path-sum/
04-10
这道题是要求从一个矩阵的左上角到右下角的最短路径和，每个位置只能往下或右走，所以可以用动态规划来解决。具体思路是先初始化第一行和第一列的路径和，之后对于每个非第一行第一列的位置，其路径和就是上面和左边...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值