# 399. 除法求值

399. 除法求值

给你一个变量对数组 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 的情况，且不存在任何矛盾的结果。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/evaluate-division
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 方法1：BFS

import "fmt"
func calcEquation(equations [][]string, values []float64, queries [][]string) []float64 {
    // 给方程组中的每个变量编号
    id := make(map[string] int)
    for _, equation := range equations {
        u, v := equation[0], equation[1]
        if _, has := id[u]; !has {
            id[u] = len(id)
        }
        if _, has := id[v]; !has {
            id[v] = len(id)
        }
    }

    // 节点数n
    n := len(id)

    // 构图
    type edge struct {
        to int 
        weight float64
    }
    graph := make([][]edge, n)
    for i, eq := range equations {
        u, v := id[eq[0]], id[eq[1]]
        graph[u] = append(graph[u], edge{v, values[i]})
        graph[v] = append(graph[v], edge{u, 1 / values[i]})
    }

    // BFS
    bfs := func(st, ed int) float64 {
        ratios := make([]float64, n)
        ratios[st] = 1
        que := []int{st}
        for len(que) > 0 {
            cur := que[0]
            que = que[1:]
            if cur == ed {
                return ratios[cur]
            }
            for _, e := range graph[cur] {
                if to := e.to; ratios[to] == 0 {
                    ratios[to] = ratios[cur] * e.weight
                    que = append(que, to)
                }
            }
        }
        return -1
    }

    // 调用
    ans := make([]float64, len(queries))
    for i, query := range queries {
        st, hasS := id[query[0]]
        ed, hasE := id[query[1]]
        if !hasS || !hasE {
            ans[i] = -1
        } else {
            ans[i] = bfs(st, ed)
        }
    }

    return ans

}

• 方法2：Floyd

func calcEquation(equations [][]string, values []float64, queries [][]string) []float64 {
    // 对每个变量编号
    id := make(map[string]int)
    for _, equation := range equations {
        u, v := equation[0], equation[1]
        if _, has := id[u]; !has {
            id[u] = len(id)
        }
        if _, has := id[v]; !has {
            id[v] = len(id)
        }
    }

    n := len(id)

    // 构图
    graph := make([][] float64, n)
    for i := range graph {
        graph[i] = make([]float64, n)
    }
    for i, equation := range equations {
        u, v := id[equation[0]], id[equation[1]]
        graph[u][v] = values[i]
        graph[v][u] = 1 / values[i]
    }

    // floyd
    // 注意是 k i j
   for k := range graph {
       for i := range graph {
           for j := range graph {
               if graph[i][k] > 0 && graph[k][j] > 0 {
                   graph[i][j] = graph[i][k] * graph[k][j]
               }
           }
       }
   }

    ans := make([] float64, len(queries))
    for i, query := range queries {
        st, hasS := id[query[0]]
        ed, hasE := id[query[1]]
        if !hasS || !hasE || graph[st][ed] == 0{
            ans[i] = -1
        } else {
            ans[i] = graph[st][ed]
        }
    }
    
    return ans
}