leetcode 399. Evaluate Division(floyed)

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>> equations, vector& values, vector<pair<string, string>> queries , where equations.size() == values.size(), and the values are positive. This represents the equations. Return vector.

According to 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.

题意：就是根据已知等式求未知等式
解：一开始用dfs过了感觉写法有点智障，就用floyed又写了一遍

unordered_map<string,int>dict;
unordered_map<int,set<int>>p;
vector<double>ans;
double q[110][110];
int vis[110]={0}, flag;


class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        ans.clear(),p.clear(),dict.clear();
        memset(vis,0,sizeof(vis));
        memset(q,0,sizeof(q));
        int id=0;
        for(int i=0;i<equations.size();i++)
        {
            string u=equations[i].first, v=equations[i].second;
            if(!dict.count(u))dict[u]=++id;
            if(!dict.count(v))dict[v]=++id;
            int a=dict[u], b=dict[v];
            q[a][b]=values[i];
            q[b][a]=1.0/values[i];
            q[a][a]=1,q[b][b]=1;
            p[a].insert(b),p[b].insert(a);
        }
        for(int k=1;k<=id;k++)
        {
            for(int i=1;i<=id;i++)
            {
                for(int j=1;j<=id;j++)
                {
                    
                    if(q[i][k]!=0&&q[k][j]!=0)
                    q[i][j]=q[i][k]*q[k][j];
                }
            }
        }
        for(int i=0;i<queries.size();i++)
        {
            string u = queries[i].first, v=queries[i].second;
            
            if(!dict.count(u)||!dict.count(v))ans.push_back(-1.0);
            else if(u==v)ans.push_back(1.0);
            else 
            {
                int a=dict[u], b=dict[v];
                if(q[a][b]==0)ans.push_back(-1);
                else ans.push_back(q[a][b]);
            }
        }
        return ans;
    }
};