#399 Evaluate Division

Description

You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable.

You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?.

Return the answers to all queries. If a single answer cannot be determined, return -1.0.

Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.

Examples

Example 1:

Input: equations = [[“a”,“b”],[“b”,“c”]], values = [2.0,3.0], queries = [[“a”,“c”],[“b”,“a”],[“a”,“e”],[“a”,“a”],[“x”,“x”]]
Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]
Explanation:
Given: a / b = 2.0, b / c = 3.0
queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
return: [6.0, 0.5, -1.0, 1.0, -1.0 ]

Example 2:

Input: equations = [[“a”,“b”],[“b”,“c”],[“bc”,“cd”]], values = [1.5,2.5,5.0], queries = [[“a”,“c”],[“c”,“b”],[“bc”,“cd”],[“cd”,“bc”]]
Output: [3.75000,0.40000,5.00000,0.20000]

Example 3:

Input: equations = [[“a”,“b”]], values = [0.5], queries = [[“a”,“b”],[“b”,“a”],[“a”,“c”],[“x”,“y”]]
Output: [0.50000,2.00000,-1.00000,-1.00000]

Constraints:

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 consist of lower case English letters and digits.

思路

这道题其实就是带weight的bfs问题，求解query的每一对start和end之间是否存在通路

比较弯弯绕绕的是这道题用的是string不是int，所以在adj/parent存储的时候需要用Map，使得整个结构比较复杂，不如数组直观
其他的就是parent存储的位置问题了，bfs的简单写法可以直接看面经整理的代码部分，加入weight就是多一个parent字典

代码

class OutGoingEdge {
    public String nextNode;
    public Double edgeValue;
    
    public OutGoingEdge(String nextNode, double edgeValue){
        this.nextNode = nextNode;
        this.edgeValue = edgeValue;
    }
}

class Solution {
    Map<String, List<OutGoingEdge>> adj = new HashMap<>();
    
    public double bfsFindPath(String start, String end){
        Map<String, Double> parentValue = new HashMap<>();
        Map<String, String> parentNode = new HashMap<>();
        
        List<String> toVisit = new ArrayList<>();
        boolean hasFoundEnd = false;
        Set<String> hasVisited = new HashSet<>();
        
        toVisit.add(start);
        hasVisited.add(start);
        
        while(toVisit.size() > 0){
            String currNode = toVisit.get(0);
            if (currNode.equals(end)){
                hasFoundEnd = true;
                break;
            }
            
            
            for (OutGoingEdge edge: adj.get(currNode)){
                if (hasVisited.contains(edge.nextNode))
                    continue;
                toVisit.add(edge.nextNode);
                parentValue.put(edge.nextNode, edge.edgeValue);
                parentNode.put(edge.nextNode, currNode);
                hasVisited.add(edge.nextNode);
            }
            toVisit.remove(0);
        }
        
        if (!hasFoundEnd)
            return -1.0;
        
        double answer = 1.0;
        while(parentNode.containsKey(end)){
            answer *= parentValue.get(end);
            end = parentNode.get(end);
        }
        return answer;
    }
    
    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
        double[] answer = new double[queries.size()];
        for (int i = 0; i < values.length; i++){
            List<String> equation = equations.get(i);
            String from = equation.get(0);
            String to = equation.get(1);
            
            if (!adj.containsKey(from))
                adj.put(from, new ArrayList<>());
            if (!adj.containsKey(to))
                adj.put(to, new ArrayList<>());
            adj.get(from).add(new OutGoingEdge(to, values[i]));
            adj.get(to).add(new OutGoingEdge(from, 1 / values[i]));
        }
        
        for (int i = 0; i < queries.size(); i++){
            List<String> query = queries.get(i);
            if (!adj.containsKey(query.get(0)) || !adj.containsKey(query.get(1)))
                answer[i] = -1.0;
            else
                answer[i] = bfsFindPath(query.get(0), query.get(1));
        }
        
        return answer;
    }
}