unit_converter.cc

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>

typedef std::pair<std::string, double> edge_t;
typedef std::map<std::string, std::vector<edge_t>> graph_t;



struct fact {
  std::string unit_from_, unit_to_;
  double ratio_;  // unit_from * ration = unit_to

  fact(std::string unit_from, std::string unit_to, double ratio)
      : unit_from_(unit_from), unit_to_(unit_to), ratio_(ratio) {}
};

double coefficient(graph_t& g, const std::string& from, const std::string& to, std::set<std::string>& visited) {
  if (visited.contains(from) || !g.contains(from)) {
    return 0;
  }
  visited.insert(from);
  if (from == to) {
    return 1;
  }
  for (const edge_t& e : g[from]) {
    double c = e.second * coefficient(g, e.first, to, visited);
    if (c != 0) {
      return c;
    }
  }
  return 0;
}

int main() {
  std::vector<fact> facts = {fact("m", "cm", 100), fact("m", "mm", 1000),
                             fact("h", "min", 60)};

  graph_t graph;

  for (const fact& f : facts) {
    std::pair<std::string, double> edge = {f.unit_to_, f.ratio_};
    if (graph.contains(f.unit_from_)) {
        graph[f.unit_from_].push_back(edge);
    } else {
        graph[f.unit_from_] = {edge};
    }
    std::pair<std::string, double> reversed_edge = {f.unit_from_, 1 / f.ratio_};
    if (graph.contains(f.unit_to_)) {
        graph[f.unit_to_].push_back(reversed_edge);
    } else {
        graph[f.unit_to_] = {reversed_edge};
    }
  }

  int N = 0;
  std::cin >> N;
  for (int i = 0; i < N; ++i) {
    std::string from, to;
    double quantity;
    std::cin >> quantity >> from >> to;

    std::set<std::string> visited;
    double ans = quantity * coefficient(graph, from, to, visited);
    if (ans == 0) {
      std::cout << "Either from or to unit is not defined in the rules" << std::endl;
      break;
    }
    std::cout << quantity << " " << from << " is " << ans << " " << to << std::endl;
  }
  

  
  return 0;
}