【Leetcode】399. Evaluate Division

最新推荐文章于 2021-12-04 11:29:46 发布

wuezs

最新推荐文章于 2021-12-04 11:29:46 发布

阅读量5.3k

点赞数 1

分类专栏： leetcode Leetcode题解java版

本文链接：https://blog.csdn.net/yeqiuzs/article/details/52506433

版权

Leetcode题解java版同时被 2 个专栏收录

289 篇文章 362 订阅

订阅专栏

leetcode

283 篇文章 0 订阅

订阅专栏

本篇博客探讨LeetCode上的第399题，即如何解决字符串形式的除法问题。题目中给出了等式字符串，要求根据给定的查询返回解答。在确保没有除零错误和矛盾的情况下，使用HashMap存储邻接表，结合DFS算法来构建图并进行深度优先搜索求解。示例解释了输入和输出格式，强调输入总是有效的，不会导致除零或矛盾的情况。

摘要由CSDN通过智能技术生成

题目链接：https://leetcode.com/contest/4/problems/evaluate-division/

题目：

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>> euqations, vector<double>& values, vector<pair<string, string>> query . where equations.size() == values.size(),the values are positive. this represents the equations.return vector<double>. .
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.

思路：

用HashMap 存储图的邻接表，并用创建图节点的visited标记。这里是图节点value是string，用数组表示visited不合适，故用hashmap<string,boolean>

DFS

算法：

	Map<String, Map<String, Double>> map = new HashMap<>();//邻接表

	public double[] calcEquation(String[][] equations, double[] values, String[][] query) {
		Set<String> set = new HashSet<String>();//记录表达式中出现的字符串
		for (int i = 0; i < equations.length; i++) {//建图
			set.add(equations[i][0]);
			set.add(equations[i][1]);
			Map<String, Double> m;
			if (map.containsKey(equations[i][0])) {
				m = map.get(equations[i][0]);
			} else {
				m = new HashMap<String, Double>();
			}
			m.put(equations[i][1], values[i]);
			map.put(equations[i][0], m);

			if (map.containsKey(equations[i][1])) {
				m = map.get(equations[i][1]);
			} else {
				m = new HashMap<String, Double>();
			}
			m.put(equations[i][0], 1.0 / values[i]);
			map.put(equations[i][1], m);

		}

		double result[] = new double[query.length];
		for (int i = 0; i < query.length; i++) {

			//初始化visited标记
			Iterator<String> it = set.iterator();
			Map<String, Boolean> visited = new HashMap<String, Boolean>();
			while (it.hasNext()) {
				visited.put(it.next(), false);
			}

			if (query[i][0].equals(query[i][1]) && set.contains(query[i][0])) {
				result[i] = 1;
				continue;
			}
			//dfs
			double res = dfs(query[i][0], query[i][1], 1, visited);
			result[i] = res;
		}
		return result;
	}

	public double dfs(String s, String t, double res, Map<String, Boolean> visited) {
		if (map.containsKey(s) && !visited.get(s)) {
			visited.put(s, true);
			Map<String, Double> m = map.get(s);
			if (m.containsKey(t)) {
				return res * m.get(t);
			} else {
				Iterator<String> keys = m.keySet().iterator();
				while (keys.hasNext()) {
					String key = keys.next();
					double state = dfs(key, t, res * m.get(key), visited);
					if (state != -1.0) {
						return state;
					}
				}
			}
		} else {
			return -1.0;
		}
		return -1.0;
	}