No399. Evaluate Division

最新推荐文章于 2018-07-29 23:14:59 发布

原创最新推荐文章于 2018-07-29 23:14:59 发布 · 296 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode

本文介绍了一种解决变量间关系问题的算法，通过构建图结构来求解给定方程组中变量间的比例关系。提供了两种方法：一是深度优先搜索实现；二是利用Floyd算法进行优化。

一、题目描述

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

二、解题思路

方法一：

首先根据题目给出的信息构建图，构建图的方式是邻接矩阵，采用map做容器，第一个元素（即键key）为除数，第二个元素（即值value）为一个pair，pair中第一个元素为除数，第二个元素为商。主函数中首先对特殊情况给予说明，如果requires中的pair中的两个元素相等，则结果为1.0，如果两个元素中有一个是未出现过的元素，则返回-1.0。下面进入正常情况，对于需要查找的pair，调用search函数，其中包含四个参数，分别为除数（源），被除数（目标），累计商，访问过的点的集合，如果得到的结果不是-1.0（如果结果为-1.0，则没有找到目标，如果结果不是-1.0，则说明找到了目标，并返回了累计商），则插入结果中。search函数首先检查该除数（源）是否被访问过（避免循环访问），如果访问过则直接返回-1.0，如果没有访问过，则继续遍历每个除数对应的每个被除数是否等最初调用search时的目标。如果不相等则继续以该被除数为除数，目标不变，调用search。对于search返回的结果需要进行判定，结果有两种，一种是是没有找到目标的-1.0，一种是找到目标的非-1.0的累计商。

class Solution {
public:
    map<string,vector<pair<string,double>>> graph;
    
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        for(int i=0;i<equations.size();i++){
            graph[equations[i].first].push_back(make_pair(equations[i].second,values[i]));
            graph[equations[i].second].push_back(make_pair(equations[i].first,1.0/values[i]));
        }
        vector<double> result;
        for(pair<string,string> q:queries){
            set<string> visited;
            if(graph.count(q.first)==0||graph.count(q.second)==0) result.push_back(-1.0);
            else if(q.first==q.second) result.push_back(1.0);
            else{
                auto temp = search(q.first,q.second,1.0,visited);
                result.push_back(temp);
            }   
        }
        return result;
    }
    double search(string source,string target,double weight,set<string> visited){
        if(visited.count(source)==0){
            visited.insert(source);
            for(pair<string,double> p:graph[source]){
            if(p.first==target)
                return p.second*weight;
            double rt= search(p.first,target,p.second*weight,visited);
            if(rt!=-1.0) return rt;
            }
        }
        return -1.0;
    }
};

方法二：

floyd算法：

Floyd算法的基本思想是：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，证明从A到X再到B的路径比A直接到B的路径短，我们便设置Dis(AB) = Dis(AX) + Dis(XB)，这样一来，当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径的距离。

使用map存储图，构建邻接矩阵，与方法一不同的地方是，用于记录除数对应的被除数和商的数据结构换做了map。对于除数和被除数相等的情况将结果设置为1.0。然后更新所有的商，使其为最大值，同时也求出了一个点到所有其他点的距离，并存储在邻接矩阵中。最后输入需要查找的起点和终点即可。

class Solution {
public:
    map<string, map<string, double>> m;
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        int n = equations.size();
        for (int i = 0; i < n; ++i) {
            m[equations[i].first][equations[i].second] = values[i];
            m[equations[i].second][equations[i].first] = 1.0 / values[i];
        }
        for (auto q: m)
        q.second[q.first] = 1.0;
    
        for (auto k = m.begin(); k != m.end(); ++k)
            for (auto i = m.begin(); i != m.end(); ++i)
                for (auto j = m.begin(); j != m.end(); ++j)
                    i->second[j->first] = max(i->second[j->first], i->second[k->first] * k->second[j->first]);
        vector<double> result;
        for (auto q: queries) {
            auto val = m[q.first][q.second];
            result.push_back(val ? val: -1.0);
        }
        return result;
    }
};