【JS每日一算法：剑指Offer系列】🟨177.除法求值(广度优先)

给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。

另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。

注意： 输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

注意： 未在等式列表中出现的变量是未定义的，因此无法确定它们的答案。

  示例 1：

输入： equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
输出： [6.00000,0.50000,-1.00000,1.00000,-1.00000]
解释：
条件：a / b = 2.0, b / c = 3.0
问题：a / c = ? , b / a = ? , a / e = ? , a / a = ? , x / x = ?
结果：[6.0, 0.5, -1.0, 1.0, -1.0 ]
注意：x 是未定义的 => -1.0

示例 2：

输入： equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
输出： [3.75000,0.40000,5.00000,0.20000]

示例 3：

输入： equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
输出： [0.50000,2.00000,-1.00000,-1.00000]

提示：

• 1 <= equations.length <= 20
• equations[i].length == 2
• 1 <= Ai.length, Bi.length <= 5
• values.length == equations.length
• 0.0 < values[i] <= 20.0
• 1 <= queries.length <= 20
• queries[i].length == 2
• 1 <= Cj.length, Dj.length <= 5
• Ai, Bi, Cj, Dj 由小写英文字母与数字组成

题解:

个人博客

更多JS版本题解点击链接关注该仓库👀

/**
 * @description: 广度优先   TC:O(n^2)  SC:O(n^2)
 * @author: JunLiangWang
 * @param {*} equations  给定被除数/除数数组
 * @param {*} values     给定结果数组
 * @param {*} queries    给定问题数组
 * @return {*}
 */
function bfs(equations, values, queries) {
    /**
     * 本方案采用广度优先搜索遍历图，首先根据equations与values
     * 构造出路径图，后续queries找到图中以被除数为起点，除数为
     * 终点的所有节点的乘积，即为答案
     */

    // 记录路径的图
    let pathMap = new Map(),
    // 记录结果的数组
        resultArray = new Array(queries.length).fill(-1);
    /// 构造出路径图，key为被除数，value为除数以及结果
    for (let i = 0; i < equations.length; i++) {
        let pathList1 = pathMap.get(equations[i][0]) || [],
            pathList2 = pathMap.get(equations[i][1]) || [];
        pathList1.push({
            to: equations[i][1],
            result: values[i]
        })
        pathList2.push({
            to: equations[i][0],
            result: 1 / values[i]
        })
        pathMap.set(equations[i][0], pathList1)
        pathMap.set(equations[i][1], pathList2)
    }
    // 遍历问题
    for (let i = 0; i < queries.length; i++) {
        // 获取以除数为起点的所有路径
        let queue = pathMap.get(queries[i][0])
        // 如果没有，则直接continue
        if (!queue) continue;
        // 结构，防止修改原数组
        queue = [...queue]
        // 记录已经走过的节点，防止回环
        let passedPathMap = new Map()
        // 当前起点已是走过的节点，记录
        passedPathMap.set(queries[i][0], true)
        while (queue.length) {
            let path = queue.shift()
            // 如果已找到除数为终点，则记录
            // 结果，然后跳出循环
            if (path.to == queries[i][1]) {
                resultArray[i] = path.result
                break;
            }
            // 如果当前节点的to是已走过的节点，直接跳过
            // 本次循环
            if (passedPathMap.get(path.to)) continue;
            // 拿到中间节点的路径
            let toPathList = pathMap.get(path.to)
            // 给队列添加路径
            for (let toPath of toPathList) {
                queue.push({
                    to: toPath.to,
                    result: toPath.result * path.result
                })
            }
            // 记录已走过的节点，防止回环
            passedPathMap.set(path.to, true)
        }
    }
    // 返回结果
    return resultArray
}