Problem 107: Minimal network

(see projecteuler.net/problem=107)

The following undirected network consists of seven vertices and twelve edges with a total weight of 243.

full network

The same network can be represented by the matrix below.

 ABCDEFG
A 161221  
B16  1720 
C12  28 31
D211728 181923
E 20 18  11
F  3119  27
G   231127

However, it is possible to optimise the network by removing some edges and still ensure that all points on the network remain connected.
The network which achieves the maximum saving is shown below. It has a weight of 93, representing a saving of 243 − 93 = 150 from the original network.

optimized network

Using network.txt (right click and 'Save Link/Target As...'), a 6K text file containing a network with forty vertices,
and given in matrix form, find the maximum saving which can be achieved by removing redundant edges whilst ensuring that the network remains connected.

Algorithm

I use Prim's algorithm (see en.wikipedia.org/wiki/Prim's_algorithm):
- done contains these nodes where all connections are optimized
- done contains initially an arbitrarily chosen node
- algorithm is finished when done contains all nodes
- in each iteration, one node is added to done

One iteration performs these tasks:
- store all edges in next where one node is in done and the other node isn't
- sort next by the weight
- pick the lowest
- add that edge to the optimized graph minimal
- add the other edge's node to done, too

There will be 40-1=39 iterations. The most time-consuming part is locating all potential edges.
The "true" algorithm of Prim uses a priority queue quite efficiently whereas I rebuild it from scratch every time.
Nevertheless, my code solves the 2500x2500 networks of Hackerrank within less than a second.

Modifications by HackerRank

- the input format is completely different
- two nodes may be connected via multiple edges
- print the optimized weight instead of the gain

My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, as well as the input data, too.

The code contains #ifdefs to switch between the original problem and the Hackerrank version.
Enable #ifdef ORIGINAL to produce the result for the original problem (default setting for most problems).

//#define ORIGINAL
 
#include <iostream>
 
#include <set>
#include <map>
#include <queue>
 
typedef unsigned int Node;
typedef unsigned int Weight;
 
// connect two nodes and assign a weight
struct Edge
{
Node from;
Node to;
Weight weight;
 
// for sorting
bool operator<(const Edge& other) const
{
// STL's priority queue returns the __largest__ element first, therefore I invert the comparison sign
if (weight != other.weight)
return weight > other.weight;
 
// sort by nodes, too, to avoid collisions of nodes with the same weight
// the order doesn't matter, these nodes just "have to be different"
if (from != other.from)
return from < other.from;
 
return to < other.to;
}
};
 
// all edges (full network)
std::map<std::pair<Node, Node>, Weight> network;
// all nodes
std::set<Node> nodes;
// weight of the full network, including duplicate connections
unsigned int initialSum = 0;
 
// insert an edge into the network, true if already existing
void addEdge(Node from, Node to, Weight weight)
{
// count all originals weights
initialSum += weight;
 
// all edges have the lower ID first (I can do that because it's an undirected graph)
if (from > to)
std::swap(from, to);
 
// already existing edge ?
auto fromTo = std::make_pair(from, to);
if (network.count(fromTo) != 0)
// has the existing edge a lower or the same weight ? => we're done
if (network[fromTo] <= weight)
return;
 
// store new (or improved) connection between two nodes
network[fromTo] = weight;
nodes.insert(from);
nodes.insert(to);
}
 
int main()
{
#ifdef ORIGINAL
// read Project Euler's weird file format
for (unsigned int i = 0; i < 40; i++)
for (unsigned int j = 0; j < 40; j++)
{
char c = 0;
unsigned int weight = 0;
// CSV-format
while (c != ',' && c != '\n')
{
c = std::cin.get();
// ignore dashes
if (c >= '0' && c <= '9')
{
weight *= 10;
weight += c - '0';
}
}
 
// only valid weights
if (weight != 0 && i < j)
addEdge(i, j, weight);
}
 
#else
 
// read Hackerrank input
unsigned int numNodes, numEdges;
std::cin >> numNodes >> numEdges;
for (unsigned int i = 0; i < numEdges; i++)
{
Node from, to;
Weight weight;
std::cin >> from >> to >> weight;
addEdge(from, to, weight);
}
#endif
 
// optimized graph, initially empty
std::set<Edge> minimal;
 
// start with a random node
std::set<Node> done;
done.insert(*nodes.begin());
 
// not all nodes optimized yet ?
while (done.size() < nodes.size())
{
// add all edges where one node is part of tree and the other isn't
std::priority_queue<Edge> next;
for (auto e : network)
{
auto fromTo = e.first;
bool hasFrom = done.count(fromTo.first) != 0;
bool hasTo = done.count(fromTo.second) != 0;
if (hasFrom == hasTo) // both nodes are already optimized or both aren't ?
continue;
 
next.push({fromTo.first, fromTo.second, e.second});
}
 
// get edge with minimal weight
auto add = next.top();
 
// add new edge to tree
done.insert(add.from); // one insert is redundant but set::set throws it away
done.insert(add.to);
 
// add edge to the optimized graph
minimal.insert(add);
}
 
// "measure" both graphs
unsigned int optimizedSum = 0;
for (auto i : minimal)
optimizedSum += i.weight;
 
#ifdef ORIGINAL
// difference
auto gain = initialSum - optimizedSum;
std::cout << gain << std::endl;
#else
std::cout << optimizedSum << std::endl;
#endif
 
return 0;
}

This solution contains 25 empty lines, 28 comments and 10 preprocessor commands.

Interactive test

This feature is not available for the current problem.

Benchmark

The correct solution to the original Project Euler problem was found in less than 0.01 seconds on a Intel® Core™ i7-2600K CPU @ 3.40GHz.
(compiled for x86_64 / Linux, GCC flags: -O3 -march=native -fno-exceptions -fno-rtti -std=c++11 -DORIGINAL)

See here for a comparison of all solutions.

Note: interactive tests run on a weaker (=slower) computer. Some interactive tests are compiled without -DORIGINAL.

Changelog

May 11, 2017 submitted solution
May 11, 2017 added comments

Hackerrank

see https://www.hackerrank.com/contests/projecteuler/challenges/euler107

My code solved 8 out of 8 test cases (score: 100%)

Difficulty

Project Euler ranks this problem at 35% (out of 100%).

Hackerrank describes this problem as easy.

Note:
Hackerrank has strict execution time limits (typically 2 seconds for C++ code) and often a much wider input range than the original problem.
In my opinion, Hackerrank's modified problems are usually a lot harder to solve. As a rule thumb: brute-force is never an option.

Links

projecteuler.net/thread=107 - the best forum on the subject (note: you have to submit the correct solution first)

Code in various languages:

Python: www.mathblog.dk/project-euler-107-efficient-network/ (written by Kristian Edlund)
Java: github.com/nayuki/Project-Euler-solutions/blob/master/java/p107.java (written by Nayuki)
Scala: github.com/samskivert/euler-scala/blob/master/Euler107.scala (written by Michael Bayne)

Heatmap

green problems solve the original Project Euler problem and have a perfect score of 100% at Hackerrank, too.
yellow problems score less than 100% at Hackerrank (but still solve the original problem).
gray problems are already solved but I haven't published my solution yet.
blue problems are already solved and there wasn't a Hackerrank version of it (at the time I solved it) or I didn't care about it because it differed too much.

Please click on a problem's number to open my solution to that problem:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
The 126 solved problems had an average difficulty of 16.0% at Project Euler and I scored 11,074 points (out of 12500) at Hackerrank's Project Euler+.
more about me can be found on my homepage.
some names mentioned on this site may be trademarks of their respective owners.
thanks to the KaTeX team for their great typesetting library !