LeetCode #399 - Evaluate Division-优快云博客

本文介绍了一种解决变量间关系求解问题的算法，通过构建有向图并利用BFS遍历，能够高效地计算出给定公式中变量之间的比例关系。适用于处理如a/b=2.0, b/c=3.0这类问题，快速响应诸如a/c=?, a/a=?等查询。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：

Equations are given in the format A / B = k, where A and 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.

构造有向图，记录边和权值，利用BFS遍历寻找终点。

class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        unordered_map<string,vector<string>> graph; // 领接表
        unordered_map<string,double> edge; // 边的权值
        for(int i=0;i<equations.size();i++)
        {
            string a=equations[i].first;
            string b=equations[i].second;
            if(graph.count(a)==0) graph[a]=vector<string>(1,b);
            else graph[a].push_back(b);
            if(graph.count(b)==0) graph[b]=vector<string>(1,a);
            else graph[b].push_back(a);
            edge[a+"_"+b]=values[i];
            edge[b+"_"+a]=1.0/values[i];
        }
        
        vector<double> result;
        for(int i=0;i<queries.size();i++)
        {
            string a=queries[i].first;
            string b=queries[i].second;
            if(graph.count(a)==0||graph.count(b)==0) result.push_back(-1.0);
            else if(a==b) result.push_back(1.0);
            else
            {
                queue<pair<string,double>> q;
                set<string> visited;
                bool find=false;
                q.push({a,1.0});
                visited.insert(a);
                while(!q.empty()) //使用队列实现BFS
                {
                    pair<string,double> p=q.front();
                    q.pop();
                    for(auto neigh:graph[p.first])
                    {
                        if(neigh==b)
                        {
                            find=true;
                            result.push_back(p.second*edge[p.first+"_"+neigh]);
                            break;
                        }
                        else
                        {
                            if(visited.count(neigh)==0)
                            {
                                q.push({neigh,p.second*edge[p.first+"_"+neigh]});
                                visited.insert(p.first);
                            }
                        }
                    }
                }
                if(!find) result.push_back(-1.0);
            }
        }
        return result;
    }
};