# Solving Leetcode Interviews in Seconds with AI: Evaluate Division


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "399" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable. You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?. Return the answers to all queries. If a single answer cannot be determined, return -1.0. Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction. Note: The variables that do not occur in the list of equations are undefined, so the answer cannot be determined for them.   Example 1:  Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]] Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000] Explanation:  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 ] note: x is undefined => -1.0 Example 2:  Input: equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]] Output: [3.75000,0.40000,5.00000,0.20000]  Example 3:  Input: equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]] Output: [0.50000,2.00000,-1.00000,-1.00000]    Constraints:  1 <= equations.length <= 20 equations[i].length == 2 1 <= Ai.length, Bi.length <= 5 values.length == equations.length 0.0 < values[i] <= 20.0 1 <= queries.length <= 20 queries[i].length == 2 1 <= Cj.length, Dj.length <= 5 Ai, Bi, Cj, Dj consist of lower case English letters and digits.  

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Build a Graph:** Represent the equations as a graph where nodes are variables, and edges represent the division relationships (A/B = value becomes an edge from A to B with weight 'value', and an edge from B to A with weight 1/value).
*   **Depth-First Search (DFS):** For each query, use DFS to traverse the graph from the starting variable to the ending variable. Multiply the edge weights along the path to find the result.
*   **Handle Undefined Cases:** If a variable is not in the graph or no path is found between the query variables, return -1.0.

*   **Runtime Complexity:** O(Q * (V + E)), where Q is the number of queries, V is the number of variables, and E is the number of equations. In this problem, V and E are both bounded by 20, but the general case is shown here.
*   **Storage Complexity:** O(V + E), for storing the graph.

	
	# Code
	```python
	def calcEquation(equations, values, queries):
    graph = {}
    for (A, B), value in zip(equations, values):
        if A not in graph:
            graph[A] = {}
        if B not in graph:
            graph[B] = {}
        graph[A][B] = value
        graph[B][A] = 1.0 / value

    def dfs(start, end, visited):
        if start not in graph or end not in graph:
            return -1.0
        if start == end:
            return 1.0
        visited.add(start)
        for neighbor, value in graph[start].items():
            if neighbor not in visited:
                result = dfs(neighbor, end, visited)
                if result != -1.0:
                    return value * result
        return -1.0

    results = []
    for C, D in queries:
        results.append(dfs(C, D, set()))
    return results
	```