Bootstrap

LeetCode 637, 67, 399


637. 二叉树的层平均值

题目链接

637. 二叉树的层平均值

标签

树 深度优先搜索 广度优先搜索 二叉树

思路

本题考查了二叉树的 层序遍历,层序遍历的思想是 广度优先搜索,广度优先搜索需要使用 队列,操作如下:

  1. 创建一个队列,用于保存每层节点。
  2. 先将根节点放入队列,代表遍历第一层。
  3. 只要队列不为空,就进行如下操作:
    1. 获取本层节点的个数。
    2. 遍历本层的所有节点,遍历操作如下:
      1. 取出当前节点。
      2. 如果当前节点的左子节点不为 null,则将其放到队列中,等待下一层节点的遍历。
      3. 如果当前节点的右子节点不为 null,则将其放到队列中,等待下一层节点的遍历。
      4. 针对当前节点进行某种操作:使用一个变量统计本层节点之和。
    3. 针对本层节点进行某种 统计 操作:计算本层节点的平均值,并将其放到结果链表中。
  4. 遍历完整个二叉树,返回结果。

代码

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>(); // 存储结果(每层节点的平均值)的链表

        LinkedList<TreeNode> queue = new LinkedList<>(); // 保存每层节点的队列
        queue.offer(root); // 先将根节点放入队列,即遍历第一层
        while (!queue.isEmpty()) { // 直到队列为空,才退出循环
            double sum = 0; // 计算本层节点的和

            int size = queue.size(); // 获取本层节点的数量
            for (int i = 0; i < size; i++) { // 遍历本层所有节点
                TreeNode curr = queue.poll(); // 取出 当前节点
                
                TreeNode left = curr.left; // 获取当前节点的 左子节点
                if (left != null) { // 如果 左子节点 不为 null
                    queue.offer(left); // 则将其放到队列中,等待下一层遍历
                }
                
                TreeNode right = curr.right; // 获取当前节点的 右子节点
                if (right != null) { // 如果 右子节点 不为 null
                    queue.offer(right); // 则将其放到队列中,等待下一层遍历
                }

                sum += curr.val; // 求和
            }

            res.add(sum / size); // 计算平均值
        }
        return res;
    }
}

67. 二进制求和

题目链接

67. 二进制求和

标签

位运算 数学 字符串 模拟

思路

本题是一道 模拟题,如果是十进制,则本题就是 高精度 问题,以下写出一种模版,只需要改变 base 进制,就可以使用不同的进制进行计算。

可以想一想小学一年级学的 列竖式计算两数之和,高精度的解决方案就是它:

  1. 将两个数的个位对齐,写出来。
  2. 对每一位,有如下操作:
    1. 将两个数的相同位加在一起。此外,还要加上 进位 carry,进位是通过 n 进一 得到的,这里的 n 就是进制。如果有一个数的位数不够,则认为这个数的这一位为 0
    2. 对于加起来的和,如果它大于进制,则进一,并将剩余的数(和 对 进制 取余)写在结果的这一位上;否则直接将和写在结果的这一位上。
  3. 最后,看是否还应该进位,如果需要,则再添加一位 1

由于 题目传入的字符串和要求返回的字符串都是从高位到低位的,而 在计算时是从低位到高位的,所以要注意在计算时颠倒字符串,并将计算结果反转之后再返回。

代码

class Solution {
    public String addBinary(String a, String b) {
        final int base = 2; // 进制,本题为 二进制

        StringBuilder builder = new StringBuilder(); // 拼接数字的拼接器
        char[] aC = a.toCharArray(), bC = b.toCharArray();
        int aLen = aC.length, bLen = bC.length;
        int len = Math.max(aLen, bLen); // 获取较长字符串的长度

        int carry = 0; // 是否要进一,如果要进一,则为 1;否则为 0
        for (int i = 0; i < len; i++) {
        	// 注意 aC/bC[i] 是字符,需要通过 减去 '0' 来将其转化为 数字
            int operand1 = i < aLen ? (aC[aLen - i - 1] - '0') : 0;
            int operand2 = i < bLen ? (bC[bLen - i - 1] - '0') : 0;
            int sum = operand1 + operand2 + carry;
            carry = sum / base; // 查看是否需要进一
            sum %= base; // 获取剩余的数
            builder.append(sum);
        }
        
        if (carry > 0) { // 如果还需要进位
            builder.append(1); // 则再添加一位 1
        }
        
        builder.reverse(); // 先将结果反转
        return builder.toString(); // 再返回
    }
}

399. 除法求值

题目链接

399. 除法求值

标签

深度优先搜索 广度优先搜索 并查集 图 数组 字符串 最短路

思路

导入

本题不算中等题,理应为困难题,主要与 并查集数学 有关,操作十分复杂。可以先看看 990. 等式方程的可满足性,990 题是本题的简单版本,尽量理解 990 题中的并查集的使用。此外,希望大家看一看并查集的 路径压缩,这在本题中很重要。

value 属性

如果能够理解 990 题,那么离解决本题就不远了。本题的并查集中每个节点都比 990 题多了一个值 value,其保存了 本节点 与 其父节点 的比值,即有 v a l u e [ i ] = i p a r e n t [ i ] value[i] = \frac{i}{parent[i]} value[i]=parent[i]i 请记住这点,在 find()union() 中很重要。注意:其中的 i, parent[i] 不是索引,没有实际意义,只是充当有逻辑意义的占位符,这个比值是从 values 数组中获得的。

find() 方法

find() 时需要 压缩路径,因为这样可以避免一些计算。例如下面的并查集,如果想要查询 xrootX 的比值,就必须计算两次;但如果直接让 x 指向 rootX,这时只需要获取 value[x] 即可。具体的操作为先保存父节点,再递归获取根节点,最后更新本节点的 value,从 本节点与父节点的比值 变为 本节点与根节点的比值。等式如下: x r o o t X = x y ∗ y r o o t X \frac{x}{rootX} = \frac{x}{y} * \frac{y}{rootX} rootXx=yxrootXy ,即 value[x] = value[x] * value[y],其中的 y 为未变更之前 x 的父节点。
alt text

union() 方法

union() 方法中,不仅要传递 x, y 的索引,还要传递 value = x / y 的值。先获取 xy 的根节点(获取根节点的时候就让 x, y 指向其根节点 rootX, rootY 了,如下图),如果根节点一样,则直接返回;否则就需要让 rootX 指向 rootY,并更新 rootXvalue。等式如下: r o o t X r o o t Y = y r o o t Y x y r o o t X x \frac{rootX}{rootY} = \frac{y}{rootY} \frac{x}{y} \frac{rootX}{x} rootYrootX=rootYyyxxrootX ,即有 value[rootX] = value[y] * value / value[x]
alt text
本题还有一个比较麻烦的点:等式中的变量不一定只有一个小写字母。所以需要建立 等式中的变量(以下称作 操作元)与 其在并查集中的索引 的映射,具体请看代码。

query() 方法

由于需要查询某两个操作元之间的比值,还需要在并查集中实现一个方法 query(),如果两个操作元对应的索引在并查集中不连通,则返回 -1;否则返回比值 value[x] / value[y]。等式如下(如果 x, y 连通,则其根节点相同,假设为 root): x y = x r o o t r o o t y \frac{x}{y} =\frac{x}{root} \frac{root}{y} yx=rootxyroot ,即 x / y = value[x] / value[y]

代码

class Solution {
    public double[] calcEquation(List<List<String>> equations,
    							double[] values, List<List<String>> queries) {
        // 先初始化并查集
        init(equations, values);

        // 再进行查询
        int queriesSize = queries.size();
        double[] res = new double[queriesSize];
        for (int i = 0; i < queriesSize; i++) {
            List<String> query = queries.get(i);
            String operand1 = query.get(0); // 操作元1
            String operand2 = query.get(1); // 操作元2
            Integer idx1 = indexMapper.get(operand1); // 操作元1的索引
            Integer idx2 = indexMapper.get(operand2); // 操作元2的索引
            if (idx1 == null || idx2 == null) { // 如果两个操作元有一个找不到
                res[i] = -1; // 则本此查询返回 -1
            } else { // 否则查询 value[idx1] / value[idx2] 的结果
                res[i] = uf.query(idx1, idx2);
            }
        }
        return res;
    }

    private UnionFind uf; // 并查集
    private Map<String, Integer> indexMapper; // 操作元 与 其在并查集中的索引 的映射

    // 初始化并查集
    private void init(List<List<String>> equations, double[] values) {
        int equationsSize = equations.size(); // 获取等式的数量
        uf = new UnionFind(2 * equationsSize); // 创建一个等式数量二倍大小的并查集
        indexMapper = new HashMap<>(2 * equationsSize);
        int idx = 0; // 操作元在并查集中的索引
        for (int i = 0; i < equationsSize; i++) {
        	// 取出每个等式,建立 操作元 与 其在并查集中的索引 的关系
            List<String> equation = equations.get(i);
            String operand1 = equation.get(0); // 操作元1
            String operand2 = equation.get(1); // 操作元2
            if (!indexMapper.containsKey(operand1)) { // 如果 索引映射 中不存在 操作元
                indexMapper.put(operand1, idx++); // 则为其建立映射
            }
            if (!indexMapper.containsKey(operand2)) { // 如果 索引映射 中不存在 操作元
                indexMapper.put(operand2, idx++); // 则为其建立映射
            }
            uf.union(indexMapper.get(operand1), indexMapper.get(operand2), values[i]);
        }
    }

    private static class UnionFind {
        private final int[] parent; // parent[i] 表示 第 i 个元素的父节点
        private final double[] value; // value[i] 表示 第 i 个元素 / 其父节点 的商

        // 初始化并查集
        public UnionFind(int size) {
            parent = new int[size];
            value = new double[size];
            for (int i = 0; i < size; i++) {
                parent[i] = i; // 初始时,每个元素的父节点都是 自己
                value[i] = 1; // 初始时,每个元素与自己的商都是 1
            }
        }

        // 查找 x 的根节点,使用了路径压缩
        public int find(int x) {
            if (x != parent[x]) { // 如果 x 不是根节点
                int temp = parent[x]; // 保存 x 的父节点
                parent[x] = find(parent[x]); // 寻找 x 的根节点
                value[x] *= value[temp]; // 给 本节点与父节点的商 乘 父节点与父节点的父节点的商
            }
            return parent[x]; // 否则返回 parent[x]
        }

        // 合并两个节点所在的集合
        public void union(int x, int y, double value) {
            int rootX = find(x); // x 的根节点
            int rootY = find(y); // y 的根节点
            if (rootX == rootY) {
                return;
            }

            parent[rootX] = rootY; // 让 x 的根节点 指向 y 的根节点,y 的根节点 成为 父节点
            value[rootX] = value[y] * value / value[x];
        }

        // 查询 value[x] / value[y] 的结果
        public double query(int x, int y) {
            if (find(x) == find(y)) { // 如果连通
                return value[x] / value[y]; // 则返回比值
            } else { // 否则不连通
                return -1; // 返回 -1
            }
        }
    }
}
;