图的应用 LeetCode 399.除法求值

LeetCode 399.除法求值

题目描述

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/evaluate-division

题解

思路

1.最开始看到题目，简单的想法是给字母根据倍数关系赋值，由于一个字母前后出现在多个方程，肯定行不通

2.字母之间不断增加的关系，多对多，且有方向性，就想到用图来解决。一个字母代表一个图节点，边的权重代表倍数关系。遍历两个节点之间的路径乘积即为结果。

示例

给定条件：

给定 a / b = 4.0, e / f = 0.2, b / e = 2.0
问题: b/ a = ?, a / f = ?, f / f = ?, e / e = ?, c / c = ?, a/ c = ?, f / e = ?
返回 [0.25, 1.6, 1.0, 1.0, -1.0, -1.0, 5.0]

图结构

图的广度优先遍历
（从b点出发）

代码实现（Python）

 def calcEquation(self, equations, values, queries):
       from collections import defaultdict, deque

       res = []
       #graph字典，节点之间连通关系
       graph=defaultdict(set)
       #weight字典，节点对之间权值
       weight=defaultdict()

       #建图
       for index,equ in enumerate(equations):
           graph[equ[0]].add(equ[1])
           graph[equ[1]].add(equ[0])
           weight[tuple(equ)]=values[index]
           weight[(equ[1],equ[0])]=float(1/values[index])

       for que in queries:
           #节点对有直接路径
           if tuple(que) in weight:
               res.append(weight[tuple(que)])
           #不存在节点
           elif que[0] not in graph or que[1] not in graph:
               res.append(-1.0)
           #同一节点
           elif que[0]==que[1]:
               res.append(1.0)
           #BFS遍历
           else:
               start,end=que[0],que[1]
               #标记访问节点
               visit=[]
               #访问节点队列
               stack = deque()
               visit.append(start)
               
               #start的相邻节点先入队列
               for t in graph[start]:
                   stack.appendleft((t,weight[start,t]))
               
               #标志遍历后能否找到节点对路径
               flag=False
               
               while len(stack) and not flag:
                   node,val=stack.pop()
                   visit.append(node)
                   
                   #不断通过相邻节点遍历
                   for t in graph[node]:
                       if t not in visit:
                           if t==end:
                               res.append(val*weight[(node,t)])
                               flag=True
                               break
                           else:
                               weight[(start,t)]=val*weight[(node,t)]
                               stack.appendleft((t,val*weight[(node,t)]))
                               
               #节点对在图中不连通
               if not flag:
                   res.append(-1.0)

       return res