Leetcode 329. Longest Increasing Path in a Matrix

-题目

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

-思路

简单的思路就是对每一个查询进行一次搜索，如果是在邻接矩阵中已经直接给出的值，那么我们可以返回这个值，如果是要通过几个基本元素的乘积来得出结果，那么用dfs算法来判断是否可以构成查询的这个元素。

要注意的是需要判断查询的元素是否存在于图中，也即x / x返回-1而不是1.

-代码

class Solution {
public:
vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
//已经确定输入合法
vector<double> result(queries.size());
if(equations.size() != values.size()) return result;

set<string> nodes;
map<string, int> node2index;
for(int i = 0; i < equations.size(); i++) {
nodes.insert(equations[i].first);
nodes.insert(equations[i].second);
}
int n = nodes.size();
vector<vector<double> > Adjmatrix(n, vector<double>(n, 0));
int index = 0;
set<string>::iterator it;
for(it = nodes.begin(); it != nodes.end(); it++) {
node2index[*it] = index++;
}
for(int i = 0; i < values.size(); i++) {
Adjmatrix[node2index[equations[i].first]][node2index[equations[i].second]] = values[i];
Adjmatrix[node2index[equations[i].second]][node2index[equations[i].first]] = 1 / values[i];
Adjmatrix[node2index[equations[i].first]][node2index[equations[i].first]] = 1;
Adjmatrix[node2index[equations[i].second]][node2index[equations[i].second]] = 1;
}
//构建初步的邻接图矩阵 用DFS求传递闭包
for(int i = 0; i < queries.size(); i++) {
//排除一些奇怪的情况
if((node2index.find(queries[i].first) == node2index.end()) || (node2index.find(queries[i].second) == node2index.end())) {

result[i] = -1;
continue;
}
if(queries[i].first == queries[i].second) {
result[i] = 1;
continue;
}
//如果不是直接可预知的 通过DFS来找到它的值
vector<bool> isVisited(n, 0);
result[i] = dfs(node2index[queries[i].first], node2index[queries[i].second], 1, isVisited, Adjmatrix);
}

return result;
}
double dfs(int s, int t, double res, vector<bool> isVisited, vector<vector<double> > Adjmatrix) {
if(!isVisited[s]) {
//如果没有访问过当前结点
//访问当前结点
isVisited[s] = 1;
//如果从s有到目标结点的路径返回
if(Adjmatrix[s][t] != 0) {
return res * Adjmatrix[s][t];
}
else {
for(int i = 0; i < Adjmatrix[s].size(); i++) {
if(Adjmatrix[s][i] != 0) {
double cres = dfs(i, t, res*Adjmatrix[s][i], isVisited, Adjmatrix);
if(cres != -1) return cres;
}
}
}
}
return -1;
}
};