Ticket #81: port_dijkstra_demo_21b33e184d46.patch

demo/CMakeLists.txt

@@ -4 +4 @@
 
 set (DEMOS
   arg_parser_demo
+  dijkstra_demo
   graph_to_eps_demo
   lgf_demo)
 

demo/Makefile.am

@@ -6 +6 @@
 
 noinst_PROGRAMS += \
         demo/arg_parser_demo \
+        demo/dijkstra_demo \
         demo/graph_to_eps_demo \
         demo/lgf_demo
 
 endif WANT_DEMO
 
 demo_arg_parser_demo_SOURCES = demo/arg_parser_demo.cc
+demo_dijkstra_demo_SOURCES = demo/dijkstra_demo.cc
 demo_graph_to_eps_demo_SOURCES = demo/graph_to_eps_demo.cc
 demo_lgf_demo_SOURCES = demo/lgf_demo.cc

new file demo/dijkstra_demo.cc

@@ +1 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+///\ingroup demos
+///\file
+///\brief Demonstrating the usage of Dijkstra algorithm
+///
+/// Dijkstra's algorithm computes shortest paths between two nodes in a
+/// digraph with arc lengths. Here we only show some of the facilities
+/// supplied by our implementation. For the detailed documentation of
+/// the LEMON Dijkstra class read \ref lemon::Dijkstra "this".
+///
+/// \include dijkstra_demo.cc
+
+#include <iostream>
+#include <lemon/list_graph.h>
+#include <lemon/dijkstra.h>
+
+using namespace lemon;
+
+int main (int, char*[])
+{
+  // Convenient type definitions
+  typedef ListDigraph Digraph;
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
+  typedef Digraph::ArcMap<int> LengthMap;
+
+  // Create a directed graph and a length map
+  Digraph g;
+
+  Node s=g.addNode();
+  Node v2=g.addNode();
+  Node v3=g.addNode();
+  Node v4=g.addNode();
+  Node v5=g.addNode();
+  Node t=g.addNode();
+
+  Arc s_v2=g.addArc(s, v2);
+  Arc s_v3=g.addArc(s, v3);
+  Arc v2_v4=g.addArc(v2, v4);
+  Arc v2_v5=g.addArc(v2, v5);
+  Arc v3_v5=g.addArc(v3, v5);
+  Arc v4_t=g.addArc(v4, t);
+  Arc v5_t=g.addArc(v5, t);
+
+  LengthMap len(g);
+
+  len.set(s_v2, 10);
+  len.set(s_v3, 10);
+  len.set(v2_v4, 5);
+  len.set(v2_v5, 8);
+  len.set(v3_v5, 5);
+  len.set(v4_t, 8);
+  len.set(v5_t, 8);
+
+  std::cout << "This program is a simple demo of the LEMON Dijkstra class."
+            << std::endl;
+  std::cout << "We calculate the shortest path from node s to node t in a digraph."
+            << std::endl << std::endl;
+
+  std::cout << "The id of s is " << g.id(s) << ", "
+            << "the id of t is " << g.id(t) << "." << std::endl;
+
+  // Run Dijkstra algorithm
+  Dijkstra<Digraph, LengthMap> dijkstra(g,len);
+  dijkstra.run(s,t);
+
+  // Print the distance
+  std::cout << "The distance of node t from node s: "
+            << dijkstra.dist(t) << std::endl;
+
+  // Print the shortest path
+  std::cout << "The shortest path from s to t goes through the "
+            << "following nodes (in reverse order): " << std::endl;
+
+  for (Node v = t; v != s; v = dijkstra.predNode(v)) {
+    std::cout << g.id(v) << "<-";
+  }
+  std::cout << g.id(s) << std::endl;
+
+  return 0;
+}