From 78cf2258a922e074f830aa23d2e1cd582da1b4bb Mon Sep 17 00:00:00 2001
From: David Rosca <roscadav@fit.cvut.cz>
Date: Sun, 8 Mar 2015 15:13:55 +0100
Subject: [PATCH] Graph shortestpath algo: Add Dijkstra algorithm + tests
---
alib2algo/src/graph/shortestpath/Dijkstra.cpp | 155 ++++++++++++++
alib2algo/src/graph/shortestpath/Dijkstra.h | 39 ++++
.../graph/shortestpath/DijkstraTest.cpp | 191 ++++++++++++++++++
.../graph/shortestpath/DijkstraTest.h | 22 ++
4 files changed, 407 insertions(+)
create mode 100644 alib2algo/src/graph/shortestpath/Dijkstra.cpp
create mode 100644 alib2algo/src/graph/shortestpath/Dijkstra.h
create mode 100644 alib2algo/test-src/graph/shortestpath/DijkstraTest.cpp
create mode 100644 alib2algo/test-src/graph/shortestpath/DijkstraTest.h
diff --git a/alib2algo/src/graph/shortestpath/Dijkstra.cpp b/alib2algo/src/graph/shortestpath/Dijkstra.cpp
new file mode 100644
index 0000000000..098b5abfd7
--- /dev/null
+++ b/alib2algo/src/graph/shortestpath/Dijkstra.cpp
@@ -0,0 +1,155 @@
+#include "Dijkstra.h"
+
+#include <exception/AlibException.h>
+
+namespace graph
+{
+
+namespace shortestpath
+{
+
+class Data
+{
+public:
+ Node start;
+ Dijkstra::Result out;
+};
+
+class Value
+{
+public:
+ Value(const Node &node, int value)
+ : node(node)
+ , value(value)
+ {
+ }
+
+ bool operator<(const Value &other) const
+ {
+ return value < other.value;
+ }
+
+ Node node;
+ int value;
+};
+
+typedef std::unordered_map<Node, std::unordered_map<Node, int>> weights_t;
+
+static weights_t weights(const DirectedGraph &g)
+{
+ int val;
+ weights_t w;
+
+ for (const DirectedEdge &e : g.getEdges()) {
+ auto &map = w[e.getFromNode()];
+ auto search = map.find(e.getToNode());
+
+ if (search == map.end()) {
+ val = g.getEdgeValue(e);
+ map[e.getToNode()] = val;
+ } else {
+ val = std::min(search->second, g.getEdgeValue(e));
+ search->second = val;
+ }
+
+ if (val < 0) {
+ throw exception::AlibException("Dijkstra: Found negative value!");
+ }
+ }
+
+ return w;
+}
+
+static weights_t weights(const UndirectedGraph &g)
+{
+ int val;
+ weights_t w;
+
+ for (const UndirectedEdge &e : g.getEdges()) {
+ auto &map = w[e.getFirstNode()];
+ auto search = map.find(e.getSecondNode());
+
+ if (search == map.end()) {
+ val = g.getEdgeValue(e);
+ map[e.getSecondNode()] = val;
+ w[e.getSecondNode()][e.getFirstNode()] = val;
+ } else {
+ val = std::min(search->second, g.getEdgeValue(e));
+ search->second = val;
+ w[e.getSecondNode()][e.getFirstNode()] = val;
+ }
+
+ if (val < 0) {
+ throw exception::AlibException("Dijkstra: Found negative value!");
+ }
+ }
+
+ return w;
+}
+
+template <typename T>
+static Dijkstra::Result dijkstra_impl(const T &graph, const Node &start)
+{
+ std::set<Value> q; // priority queue
+ Dijkstra::Result d; // distances
+ weights_t w = weights(graph); // minimum weights
+
+ d[start] = 0;
+ q.insert(Value(start, 0));
+
+ while (!q.empty()) {
+ Node u = q.begin()->node; q.erase(q.begin());
+
+ for (const Node &v : graph.neighbors(u)) {
+ int val = d.at(u) + w[u][v];
+ auto search = d.find(v);
+
+ if (search == d.end() || search->second > val) {
+ if (search != d.end()) {
+ q.erase(q.find(Value(v, search->second)));
+ }
+
+ q.insert(Value(v, val));
+ d[v] = val;
+ }
+ }
+ }
+
+ return d;
+}
+
+Dijkstra::Result Dijkstra::dijkstra(const Graph &graph, const Node &start)
+{
+ Data data;
+ data.start = start;
+ graph.getData().Accept(static_cast<void*>(&data), DIJKSTRA);
+ return data.out;
+}
+
+Dijkstra::Result Dijkstra::dijkstra(const DirectedGraph &graph, const Node &start)
+{
+ return dijkstra_impl(graph, start);
+}
+
+Dijkstra::Result Dijkstra::dijkstra(const UndirectedGraph &graph, const Node &start)
+{
+ return dijkstra_impl(graph, start);
+}
+
+void Dijkstra::Visit(void *data, const DirectedGraph &graph) const
+{
+ Data d = *static_cast<Data*>(data);
+ d.out = dijkstra(graph, d.start);
+}
+
+void Dijkstra::Visit(void *data, const UndirectedGraph &graph) const
+{
+ Data d = *static_cast<Data*>(data);
+ d.out = dijkstra(graph, d.start);
+}
+
+const Dijkstra Dijkstra::DIJKSTRA;
+
+} // namespace shortestpath
+
+} // namespace graph
diff --git a/alib2algo/src/graph/shortestpath/Dijkstra.h b/alib2algo/src/graph/shortestpath/Dijkstra.h
new file mode 100644
index 0000000000..d9373e3ca3
--- /dev/null
+++ b/alib2algo/src/graph/shortestpath/Dijkstra.h
@@ -0,0 +1,39 @@
+#ifndef GRAPH_DIJKSTRA_H_
+#define GRAPH_DIJKSTRA_H_
+
+#include <unordered_map>
+
+#include <graph/Graph.h>
+#include <graph/directed/DirectedGraph.h>
+#include <graph/undirected/UndirectedGraph.h>
+
+namespace graph
+{
+
+namespace shortestpath
+{
+
+// Dijkstra only works on graphs without negative-weight edges (>= 0)
+
+class Dijkstra : public graph::VisitableGraphBase::const_visitor_type
+{
+public:
+ typedef std::unordered_map<Node, int> Result;
+
+ static Result dijkstra(const Graph &graph, const Node &start);
+
+ static Result dijkstra(const DirectedGraph &graph, const Node &start);
+ static Result dijkstra(const UndirectedGraph &graph, const Node &start);
+
+private:
+ void Visit(void *data, const DirectedGraph &graph) const;
+ void Visit(void *data, const UndirectedGraph &graph) const;
+
+ static const Dijkstra DIJKSTRA;
+};
+
+} // namespace shortestpath
+
+} // namespace graph
+
+#endif // GRAPH_DIJKSTRA_H_
diff --git a/alib2algo/test-src/graph/shortestpath/DijkstraTest.cpp b/alib2algo/test-src/graph/shortestpath/DijkstraTest.cpp
new file mode 100644
index 0000000000..6b1b2b65bf
--- /dev/null
+++ b/alib2algo/test-src/graph/shortestpath/DijkstraTest.cpp
@@ -0,0 +1,191 @@
+#include "DijkstraTest.h"
+
+#include "graph/shortestpath/Dijkstra.h"
+
+#include <exception/AlibException.h>
+
+CPPUNIT_TEST_SUITE_REGISTRATION(GraphDijkstraTest);
+
+void GraphDijkstraTest::testSimple()
+{
+ // Common
+ graph::shortestpath::Dijkstra::Result res;
+ graph::Node n1("n1");
+ graph::Node n2("n2");
+ graph::Node n3("n3");
+ graph::Node n4("n4");
+ graph::Node n5("n5");
+ graph::Node n6("n6");
+
+ // Directed
+ graph::DirectedGraph dg;
+ dg.addEdge(graph::DirectedEdge(n1, n2), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n3), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n4), 1);
+ dg.addEdge(graph::DirectedEdge(n1, n5), 6);
+ dg.addEdge(graph::DirectedEdge(n2, n5), 3);
+ dg.addEdge(graph::DirectedEdge(n5, n6), 2);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(dg, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(5, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(7, res[n6]);
+
+ // Undirected
+ graph::UndirectedGraph ug;
+ ug.addEdge(graph::UndirectedEdge(n1, n2), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n3), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n4), 1);
+ ug.addEdge(graph::UndirectedEdge(n1, n5), 6);
+ ug.addEdge(graph::UndirectedEdge(n2, n5), 3);
+ ug.addEdge(graph::UndirectedEdge(n5, n6), 2);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(ug, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(5, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(7, res[n6]);
+}
+
+void GraphDijkstraTest::testCycle()
+{
+ // Common
+ graph::shortestpath::Dijkstra::Result res;
+ graph::Node n1("n1");
+ graph::Node n2("n2");
+ graph::Node n3("n3");
+ graph::Node n4("n4");
+ graph::Node n5("n5");
+ graph::Node n6("n6");
+
+ // Directed
+ graph::DirectedGraph dg;
+ dg.addEdge(graph::DirectedEdge(n1, n2), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n3), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n4), 1);
+ dg.addEdge(graph::DirectedEdge(n1, n5), 6);
+ dg.addEdge(graph::DirectedEdge(n2, n5), 3);
+ dg.addEdge(graph::DirectedEdge(n5, n6), 2);
+ dg.addEdge(graph::DirectedEdge(n6, n1), 1);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(dg, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(5, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(7, res[n6]);
+
+ // Undirected
+ graph::UndirectedGraph ug;
+ ug.addEdge(graph::UndirectedEdge(n1, n2), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n3), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n4), 1);
+ ug.addEdge(graph::UndirectedEdge(n1, n5), 6);
+ ug.addEdge(graph::UndirectedEdge(n2, n5), 3);
+ ug.addEdge(graph::UndirectedEdge(n5, n6), 2);
+ ug.addEdge(graph::UndirectedEdge(n6, n1), 1);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(ug, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(5, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n6]);
+}
+
+void GraphDijkstraTest::testMultiEdge()
+{
+ // Common
+ graph::shortestpath::Dijkstra::Result res;
+ graph::Node n1("n1");
+ graph::Node n2("n2");
+ graph::Node n3("n3");
+ graph::Node n4("n4");
+ graph::Node n5("n5");
+ graph::Node n6("n6");
+
+ // Directed
+ graph::DirectedGraph dg;
+ dg.addEdge(graph::DirectedEdge(n1, n2), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n2, "multi"), 1);
+ dg.addEdge(graph::DirectedEdge(n1, n3), 2);
+ dg.addEdge(graph::DirectedEdge(n1, n4), 1);
+ dg.addEdge(graph::DirectedEdge(n1, n5), 6);
+ dg.addEdge(graph::DirectedEdge(n2, n5), 3);
+ dg.addEdge(graph::DirectedEdge(n5, n6), 2);
+ dg.addEdge(graph::DirectedEdge(n6, n1), 1);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(dg, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(4, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(6, res[n6]);
+
+ // Undirected
+ graph::UndirectedGraph ug;
+ ug.addEdge(graph::UndirectedEdge(n1, n2), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n2, "multi"), 1);
+ ug.addEdge(graph::UndirectedEdge(n1, n3), 2);
+ ug.addEdge(graph::UndirectedEdge(n1, n4), 1);
+ ug.addEdge(graph::UndirectedEdge(n1, n5), 6);
+ ug.addEdge(graph::UndirectedEdge(n2, n5), 3);
+ ug.addEdge(graph::UndirectedEdge(n5, n6), 2);
+
+ res = graph::shortestpath::Dijkstra::dijkstra(ug, n1);
+
+ CPPUNIT_ASSERT_EQUAL(0, res[n1]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n2]);
+ CPPUNIT_ASSERT_EQUAL(2, res[n3]);
+ CPPUNIT_ASSERT_EQUAL(1, res[n4]);
+ CPPUNIT_ASSERT_EQUAL(4, res[n5]);
+ CPPUNIT_ASSERT_EQUAL(6, res[n6]);
+}
+
+void GraphDijkstraTest::testNegativeValue()
+{
+ // Common
+ bool exception;
+ graph::shortestpath::Dijkstra::Result res;
+ graph::Node n1("n1");
+ graph::Node n2("n2");
+
+ // Directed
+ graph::DirectedGraph dg;
+ dg.addEdge(graph::DirectedEdge(n1, n2), -2);
+
+ exception = false;
+ try {
+ res = graph::shortestpath::Dijkstra::dijkstra(dg, n1);
+ } catch (exception::AlibException) {
+ exception = true;
+ }
+
+ CPPUNIT_ASSERT_EQUAL(true, exception);
+
+ // Undirected
+ graph::UndirectedGraph ug;
+ ug.addEdge(graph::UndirectedEdge(n1, n2), -2);
+
+ exception = false;
+ try {
+ res = graph::shortestpath::Dijkstra::dijkstra(ug, n1);
+ } catch (exception::AlibException) {
+ exception = true;
+ }
+
+ CPPUNIT_ASSERT_EQUAL(true, exception);
+}
diff --git a/alib2algo/test-src/graph/shortestpath/DijkstraTest.h b/alib2algo/test-src/graph/shortestpath/DijkstraTest.h
new file mode 100644
index 0000000000..d6ddfb568c
--- /dev/null
+++ b/alib2algo/test-src/graph/shortestpath/DijkstraTest.h
@@ -0,0 +1,22 @@
+#ifndef DIJKSTRA_TEST_H_
+#define DIJKSTRA_TEST_H_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class GraphDijkstraTest : public CppUnit::TestFixture
+{
+ CPPUNIT_TEST_SUITE(GraphDijkstraTest);
+ CPPUNIT_TEST(testSimple);
+ CPPUNIT_TEST(testCycle);
+ CPPUNIT_TEST(testMultiEdge);
+ CPPUNIT_TEST(testNegativeValue);
+ CPPUNIT_TEST_SUITE_END();
+
+public:
+ void testSimple();
+ void testCycle();
+ void testMultiEdge();
+ void testNegativeValue();
+};
+
+#endif // DIJKSTRA_TEST_H_
--
GitLab