LeetCode 除法求值（深度优先搜索DFS+广度优先搜索BFS）

给出方程式 A / B = k, 其中 A 和 B 均为代表字符串的变量， k 是一个浮点型数字。根据已知方程式求解问题，并返回计算结果。如果结果不存在，则返回 -1.0。

示例 :

给定 a / b = 2.0, b / c = 3.0
问题: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? 
返回 [6.0, 0.5, -1.0, 1.0, -1.0 ]

输入为: vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries(方程式，方程式结果，问题方程式)，
其中 equations.size() == values.size()，即方程式的长度与方程式结果长度相等（程式与结果一一对应），并且结果值均为正数。
以上为方程式的描述。 返回vector<double>类型。

基于上述例子，输入如下：

equations(方程式) = [ ["a", "b"], ["b", "c"] ],
values(方程式结果) = [2.0, 3.0],
queries(问题方程式) = [ ["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"] ]. 
输入总是有效的。你可以假设除法运算中不会出现除数为0的情况，且不存在任何矛盾的结果。

思路分析：如示例中的a / b和b / c需要求解a / c，a / c == (a / b) * (b / c)。这个过程是不是有点类似于a到b，然后b到c，这不就是一个图的问题吗？
方法一：使用深度优先搜索法。

class Solution {
public:
	set<string> points;//点集
	vector<double> result;//储存结果
	map<pair<string, string>, double> myMap;//myMap[{a,b}]代表a / b的值
	vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
		int equationsSize = equations.size();
        //第一步：利用equations和values进行建图
		for (int index = 0; index < equationsSize; ++index) {
			//将点放入点集
			points.insert(equations[index].first);
			points.insert(equations[index].second);
			//构建边的信息
			myMap[equations[index]] = values[index];//正向
			myMap[{equations[index].second, equations[index].first}] = 1 / values[index];//反向
		}
		int queriesSize = queries.size();
        //第二步：求解queries
		for (int index = 0; index < queriesSize; ++index) {
			if (points.find(queries[index].first) == points.end() || points.find(queries[index].second) == points.end()) {
				//首先检测两个点是否都存在于点集
				result.push_back(-1.0);
			}
			else if (queries[index].first == queries[index].second) {
				//如果是a / a == 1.0
				result.push_back(1.0);
			}
			else {
				set<string> visited;//求解过程中，已经访问过的点
				visited.insert(queries[index].first);
				if (dfs(queries[index], queries[index].first, 1.0, visited) == false){
                    //如果检测了所有点集中的所有点，仍然没有找到可达路径，则说明这两点不可达
                    result.push_back(-1);
                }
			}
		}
        return result;
	}
    //start为需要求解方程，nowPosition正处于的节点，tempRes中间结果， 已经访问过的点visited
	bool dfs(pair<string, string> &start, string nowPosition, double tempRes, set<string> &visited) {
		if (nowPosition == start.second) {
			//已经到达目的地
			result.push_back(tempRes);
			return true;
		}
        //在点集中搜索下一个点
		for (auto &nextPoint : points) {
			if (myMap.count({nowPosition, nextPoint}) > 0 && visited.find(nextPoint) == visited.end()) {
                //如果nowPosition可达这个点，且这个点没有访问过
				visited.insert(nextPoint);//标记访问
				if (dfs(start, nextPoint, tempRes * myMap[{nowPosition, nextPoint}], visited)) {
                    //如果已经成功求解，直接放回，无需再次递归搜索
					return true;
				}
				visited.erase(nextPoint);//清除标记
			}
		}
		return false;
	}
};

方法二：利用队列的辅助，进行广度优先搜索。

class Solution {
public:
	set<string> points;//点集
	vector<double> result;//储存结果
	map<pair<string, string>, double> myMap;//myMap[{a,b}]代表a / b的值
	vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
		int equationsSize = equations.size();
		//第一步：利用equations和values进行建图
		for (int index = 0; index < equationsSize; ++index) {
			//将点放入点集
			points.insert(equations[index].first);
			points.insert(equations[index].second);
			//构建边的信息
			myMap[equations[index]] = values[index];//正向
			myMap[{equations[index].second, equations[index].first}] = 1 / values[index];//反向
		}
		int queriesSize = queries.size();
		//第二步：求解queries
		for (int index = 0; index < queriesSize; ++index) {
			if (points.find(queries[index].first) == points.end() || points.find(queries[index].second) == points.end()) {
				//首先检测两个点是否都存在于点集
				result.push_back(-1.0);
			}
			else {
				set<string> visited;//求解过程中，已经访问过的点
				queue<pair<string, double>> myQue;//广度优先搜索辅助队列
				myQue.push({ queries[index].first, 1.0 });
				while (!myQue.empty()) {
					pair<string, double> frontPoint = myQue.front();//获取当前队头
					myQue.pop();
					if (frontPoint.first == queries[index].second) {
						//如果已经到达结尾
						result.push_back(frontPoint.second);
						break;
					}
					//在点集中搜索下一个点
					for (auto &nextPoint : points) {
						if (myMap.count({ frontPoint.first, nextPoint }) > 0 && visited.find(nextPoint) == visited.end()) {
							//如果nowPosition可达这个点，且这个点没有访问过
							visited.insert(nextPoint);//标记访问
							myQue.push({ nextPoint, frontPoint.second * myMap[{ frontPoint.first, nextPoint }] });
						}
					}
				}
				//如果经过上面的搜索还没找到，说明两点不可达
				if (result.size() == index) {
					result.push_back(-1.0);
				}
			}
		}
		return result;
	}
};

代码虽然有些长，但是思路还是很清晰的，希望能够帮助到大家进行理解。