#include <iostream>
#include <map>
#include <vector>
using namespace std;

class Graph {
  class Vertex {
  public:
    map<int, double> edges;
    Vertex() {}
    ~Vertex() { edges.clear(); }
  };

  map<int, Vertex> vertices;

public:
  bool addVertex(int number);
  bool addEdge(int start, int end, double weight);
  bool removeEdge(int start, int end);
  bool removeVertexEdges(int number);
  bool removeVertex(int number);
  bool weight(double &result, const vector<int> &path);

  Graph() {}
  ~Graph() { vertices.clear(); }
};

typedef vector<int>::const_iterator Vertex_ci;
typedef map<int, double>::const_iterator Edge_ci;

typedef map<int, Graph::Vertex>::iterator Vertex_it;
typedef map<int, double>::iterator Edge_it;

bool Graph::addVertex(int number) {
  Vertex vertex;

  if (vertices.find(number) != vertices.end())
    return false;

  vertices.insert(pair<int, Vertex>(number, vertex));
  return true;
}

bool Graph::addEdge(int start, int end, double weight) {
  Vertex_it source_it = vertices.find(start);
  Vertex_it destination_it = vertices.find(end);
  bool vertices_exist_in_graph = (source_it != vertices.end() && destination_it != vertices.end());

  if (vertices_exist_in_graph) {
    Vertex &source = source_it->second;
    Vertex &destination = destination_it->second;

    bool edges_between_given_vertices_do_not_exist = (source.edges.find(end) == source.edges.end() && destination.edges.find(start) == destination.edges.end());

    if (edges_between_given_vertices_do_not_exist) {
      source.edges.insert(pair<int, double>(end, weight));
      destination.edges.insert(pair<int, double>(start, weight));

      return true;
    }
  }

  return false;
}

bool Graph::removeEdge(int start, int end) {
  Vertex_it source_it = vertices.find(start);
  Vertex_it destination_it = vertices.find(end);
  bool vertices_exist_in_graph = (source_it != vertices.end() && destination_it != vertices.end());

  if (vertices_exist_in_graph) {
    Vertex &source = source_it->second;
    Vertex &destination = destination_it->second;

    return (source.edges.erase(end) && destination.edges.erase(start));
  }

  return false;
}

bool Graph::removeVertexEdges(int number) {
   Vertex_it vertex_it = vertices.find(number);
   bool all_vertex_edges_were_removed = true;

  if (vertex_it != vertices.end()) {
    Vertex &removed_vertex = vertex_it->second;

    for (Edge_it edge_it = removed_vertex.edges.begin(); edge_it != removed_vertex.edges.end(); edge_it++) {
      bool result_of_removing_edge = removeEdge(number, edge_it->first);

      if (all_vertex_edges_were_removed)
        all_vertex_edges_were_removed = result_of_removing_edge;
    }

    return all_vertex_edges_were_removed;
  }
  else { return false; }
}

bool Graph::removeVertex(int number) {
  if (removeVertexEdges(number))
    return (vertices.erase(number));
  else
    return false;
}

bool Graph::weight(double &result, const vector<int> &path) {
  double length = 0.0;
  bool valid_path = (path.size() > 1);

  for (Vertex_ci previous_number = path.begin(), current_number = path.begin() + 1; current_number != path.end(); current_number++, previous_number++) {
    Vertex_it current_vertex_it = vertices.find(*current_number);

    if (current_vertex_it == vertices.end()) {
      valid_path = false;
      break;
    }
    else {
      Vertex &current_vertex = current_vertex_it->second;
      Edge_ci edge_ci = current_vertex.edges.find(*previous_number);

      if (edge_ci != current_vertex.edges.end()) {
        length += edge_ci->second;
      }
      else {
        valid_path = false;
        break;
      }
    }
  }

  result = (valid_path) ? length : 0.0;
  return valid_path;
}

int main() {
  Graph graph;

  graph.addVertex(11);
  graph.addVertex(8);
  graph.addVertex(37);

  graph.addEdge(11, 8, 4.0);
  graph.addEdge(37, 8, 5.0);

  graph.removeVertex(11);

  vector<int> path;

  path.push_back(37);
  path.push_back(8);

  double length;

  graph.weight(length, path);

  cout << length << endl;
}