399. Evaluate Division（计算除法的值）

399. Evaluate Division（计算除法的值）

题目链接

https://leetcode.com/problems/evaluate-division/description/

题目描述

Equations are given in the format A / B = k, where Aand B are variables represented as strings, and k is a real number (floating point number). Given some queries, return the answers. If the answer does not exist, return -1.0.

Example:
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 ].

The input is: vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries, where equations.size() == values.size(), and the values are positive. This represents the equations. Return vector<double>.

According to the example above:

equations = [ [“a”, “b”], [“b”, “c”] ],
values = [2.0, 3.0],
queries = [ [“a”, “c”], [“b”, “a”], [“a”, “e”], [“a”, “a”], [“x”, “x”] ].

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

题目分析

这道题目的描述看起来很直观，算法也很直观，从给定节点开始深搜，搜到给定的结束节点即可。为了加快速度，可以加上并查集，若答案不存在就不必搜索。

方法：深搜+并查集

算法描述

1. 以某种中意的方式把图保存下来，在建图的同时使用并查集
2. 对于每一个要求的除法，利用并查集查看除数和被除数是否在一个集合中：
   
   • 若在一个集合中：从被除数开始深搜，直到搜到除数为止，途径边的积即位商
   • 若不在一个集合中：答案是-1.0

参考代码

class Solution {
private:
    map<string, vector<pair<string, double> > > graph;

    double DFS(const string& start, const string& end, map<string, bool>& isVisited) {
        if (start == end)
            return 1.0;

        for (auto next : graph[start]) {
            if (!isVisited[next.first]) {
                isVisited[next.first] = true;
                double temp = DFS(next.first, end, isVisited);
                if (temp != 0)
                    return next.second * temp;
            }
        }

        return 0;
    }

public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        deque<set<string> > disjointSet;
        map<string, int> flags;

        for (int i = 0; i < equations.size(); i++) {
            bool exit1 = !(graph.find(equations[i].first) == graph.end()),
                 exit2 = !(graph.find(equations[i].second) == graph.end());
            if (exit1 && exit2) {
                int n = flags[equations[i].first], m = flags[equations[i].second];
                for (auto element : disjointSet[m]) {
                    disjointSet[n].insert(element);
                    flags[element] = n;
                }
                disjointSet.erase(disjointSet.begin() + m);
            }
            else if (exit1 && !exit2) {
                disjointSet[flags[equations[i].first]].insert(equations[i].second);
                flags[equations[i].second] = flags[equations[i].first];
            }
            else if (!exit1 && exit2) {
                disjointSet[flags[equations[i].second]].insert(equations[i].first);
                flags[equations[i].first] = flags[equations[i].second];
            }
            else {
                set<string> temp;
                temp.insert(equations[i].first);
                temp.insert(equations[i].second);
                disjointSet.push_back(temp);
                flags[equations[i].first] = flags[equations[i].second] = disjointSet.size() - 1;
            }

            if (!exit1) {
                vector<pair<string, double> > temp;
                temp.push_back(make_pair(equations[i].second, values[i]));
                graph.insert(make_pair(equations[i].first, temp));
            }
            else {
                graph[equations[i].first].push_back(make_pair(equations[i].second, values[i]));
                exit1 = true;
            }

            if (values[i] != 0)
                if (!exit2) {
                    vector<pair<string, double> > temp;
                    temp.push_back(make_pair(equations[i].first, 1 / values[i]));
                    graph.insert(make_pair(equations[i].second, temp));
                }
                else {
                    graph[equations[i].second].push_back(make_pair(equations[i].first, 1 / values[i]));
                }
        }

        vector<double> results;
        for (auto q : queries) {
            map<string, bool> isVisited;
            isVisited[q.first] = true;
            if (flags.find(q.first) != flags.end() && flags.find(q.second) != flags.end() && flags[q.first] == flags[q.second])
                    results.push_back(DFS(q.first, q.second, isVisited));
            else
                results.push_back(-1.0);
        }
        return results;

    }
};