Evaluate Division (Leetcode 399)

G家的一道面试题。这道题相当于weighted graph。用adjacency matrix会好，然而
vector<256, vector<256, 0>> 这种方法不便于搜索。于是用unordered_map, 建立类似于adjacency list的adj matrix。

BFS:

class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        
        if(equations.empty() || equations.size() != values.size()) return vector<double>();
        int size = equations.size();
        unordered_map<string, vector<pair<string, double>>> adj;
        
        for(int i=0; i<equations.size(); i++){
            auto it = equations[i];
            adj[it.first].push_back({it.second, values[i]});
            adj[it.second].push_back({it.first, 1.0/values[i]});
            adj[it.first].push_back({it.first, 1.0});
            adj[it.second].push_back({it.second, 1.0});

        }
        vector<double> res;
        for(int i=0; i<queries.size(); i++){
            auto query = queries[i];
            if(!adj.count(query.first) || !adj.count(query.second)){
                res.push_back(-1.0);
                continue;
            }
            if(query.first == query.second){
                res.push_back(1.0);
                continue;
            }
            queue<pair<string, double>> q;
            set<string> st;
            q.push({query.first, 1.0});
            bool find = false;
            while(!q.empty()){
                auto cur = q.front(); q.pop();
                if(cur.first == query.second){
                    res.push_back(cur.second);
                    find = true;
                    break;
                }else{
                    st.insert(cur.first);
                    auto vt = adj[cur.first];
                    for(int i=0; i<vt.size(); i++){
                        if(st.count(vt[i].first)) continue;
                        st.insert(vt[i].first);
                        q.push({vt[i].first, cur.second * vt[i].second});
                    }
                }
            }
            if(!find) res.push_back(-1.0);
        }
        return res;
    }
};

DFS:

class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        
        if(equations.empty() || equations.size() != values.size()) return vector<double>();
        int size = equations.size();
        unordered_map<string, vector<pair<string, double>>> adj;
        
        for(int i=0; i<equations.size(); i++){
            auto it = equations[i];
            adj[it.first].push_back({it.second, values[i]});
            adj[it.second].push_back({it.first, 1.0/values[i]});
            adj[it.first].push_back({it.first, 1.0});
            adj[it.second].push_back({it.second, 1.0});

        }
        vector<double> res;
        for(int i=0; i<queries.size(); i++){
            auto query = queries[i];
            if(!adj.count(query.first) || !adj.count(query.second)){
                res.push_back(-1.0);
                continue;
            }
            if(query.first == query.second){
                res.push_back(1.0);
                continue;
            }
            set<string> st;
            double ret = dfs(adj, st, query.first, query.second, 1.0);
            res.push_back(ret);
        }
        return res;
    }
    
    double dfs(unordered_map<string, vector<pair<string, double>>> &adj, set<string> st, string cur, string des, double weight){
        if(st.count(cur)) return -1.0;
        else if(cur == des) return weight;
        st.insert(cur);
        auto vt = adj[cur];
        for(int i=0; i<vt.size(); i++){
            if(st.count(vt[i].first)) continue;
            double result = dfs(adj, st, vt[i].first, des, weight * vt[i].second);
            if(result != -1.0) return result;
        }
        return -1.0;
    }
};