optimalRoutes.

py

import sys
import math
from copy import deepcopy

def floyd(edges):
distances = edges
for a in distances: # populate missing values
for b in distances:
if a != b and len([item for item in distances[a] if item[0] == b]) == 0:
distances[a].append(tuple([b, float("inf")]))
for a in distances:
distances[a] = sorted(distances[a])
for k, key in enumerate(distances):
for j, jkey in enumerate(distances):
for i, ikey in enumerate(distances):
if distances[ikey][k] != float("inf") and distances[key][j][1] != float("inf") and distances[ikey][k][1] + distances[key][j]
[1] < distances[ikey][j][1]:
x = tuple([distances[ikey][j][0], distances[ikey][k][1] + distances[key][j][1]]) #replace mapped tuple, same first
element
distances[ikey][j] = x
return distances

origin = sys.stdin.readline().strip()
n = int(sys.stdin.readline())
distances = {}
roads = {} # mapps lowercase to original for sorting
distances[origin] = []
for i in range(0, n):
data = [ x.strip() for x in sys.stdin.readline().split(',')]
road = data[0]
roads[road.lower()] = road
distance = int(data[1])
distances[road] = []
distances[road].append(tuple([origin, distance]))
distances[origin].append(tuple([road, distance]))

n = int(sys.stdin.readline())
for i in range(0, n):
connections = [x.strip() for x in sys.stdin.readline().split(',')]
a = connections[0]
b = connections[1]
if a not in distances:
 distances[a] = []
if b not in distances:
distances[b] = []
c = int(connections[2])
if tuple([b, c]) not in distances[a]:
distances[a].append(tuple([b, c]))
if tuple([a, c]) not in distances[b]:
distances[b].append(tuple([a, c]))
result = floyd(deepcopy(distances))
print(result)
for k in sorted(roads):
entry = roads[k]
x = dict(distances[origin])
y = dict(result[origin])
ans = 'YES' if x[entry] == y[entry] else 'NO'
print('{0} {1}'.format(entry, ans))

hurricaneRecovery.cpp

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include<string>
#include<sstream>
#include<map>
#include<unordered_set>
#include <unordered_map>
#include<map>
#include <queue>
#include <set>
#include <climits>
using namespace std;

struct Node
{
string data;
vector<pair<Node *, int>> neighbors;
public:
Node(string s)
{
data = s;
neighbors = {};
 }
};
Node *minNode(unordered_map<Node *, pair<Node *, int>> &dist)
{
int mDist = INT_MAX;
Node *mNode = nullptr;
for(auto p : dist)
{
if(p.second.second <= mDist)
{
mDist = p.second.second;
mNode = p.first;
}
}
return mNode;
}

vector<pair<pair<Node *, Node*>, int>> prims(vector<Node *> &nodes)

{
auto ans = vector<pair<pair<Node *, Node*>, int>>();
auto dist = unordered_map<Node *, pair<Node *, int>>();
for(Node *node : nodes)
{
dist[node] = pair<Node *, int>(nullptr, INT_MAX);
}
for(int i = 0; i < nodes.size(); i++) // iterate over number of nodes because that is how many nodes will be in the mst
{
Node *mNode = minNode(dist);// gets min node - the node with the smallest weight between it and ANY node in the mst

if(dist[mNode].first != nullptr) // checks this isn't the first node we picked

{
auto p = pair<Node *, Node*>(mNode, dist[mNode].first);
ans.push_back(pair<pair<Node *, Node*>, int>(p, dist[mNode].second));
}
dist.erase(mNode);
// removes min node from map because we already chose it (already in the mst)
for(auto neighbor : mNode->neighbors)
{
if (dist.count(neighbor.first) && neighbor.second < dist[neighbor.first].second)
dist[neighbor.first] = pair<Node *, int>(mNode, neighbor.second);
}
}
return ans;
}
bool inNeighbors(Node *source, Node *dest)
{
for(auto p : source->neighbors)
 {
if(p.first->data == dest->data)
return true;
}
return false;
}

int main ()
{
vector<Node *> graph;

int n; // town counts

int r; // road counts
Node *source;
Node *dest;
map<string, Node*> nodes; // stores which nodes have already been encountered
string line;
int lineCount = 0;

// read in towns and add to the things

cin >> n;
cin.ignore(1000,'\n');
for(int i = 0; i < n; i++) // get da nodes
{
getline(cin, line);// read in line
string node = line;
dest = new Node(node);
nodes[node] = dest;
graph.push_back(dest);

dest = nullptr; // reset destination each time

}
cin >> r;
cin.ignore(1000,'\n');
for(int i = 0; i < r; i++) // get da roads
{
source = nullptr; // reset source each time
dest = nullptr; // reset dest each time

getline(cin, line);// read in line

int endpos = line.find(','); // get source

string node1 = line.substr(0, endpos);

line = line.substr(endpos + 1, line.length()-1);

endpos = line.find(',');
 string node2 = line.substr(1, endpos-1); // get destination

int num = stoi(line.substr(endpos + 1, line.length()-1));// get distance

if(nodes.count(node1) == 0)
{
source = new Node(node1);
nodes[node1] = source;
graph.push_back(source);
}
else
{
source = nodes[node1];
}

if(nodes.count(node2) == 0)
{
dest = new Node(node2);
nodes[node2] = dest;
graph.push_back(dest);
}
else
{
dest = nodes[node2];
}
// set connections
if(!inNeighbors(source, dest))
{
pair<Node *, int> p1 (dest, num);
source->neighbors.push_back(p1);

pair<Node *, int> p2 (source, num);

dest->neighbors.push_back(p2);
}

}
auto edges = prims(graph);
int ans = 0;
for (auto e : edges)
ans += e.second;
cout << ans;