Ticket #81: port_topological_ordering_0c44cf0a18b1.patch

demo/CMakeLists.txt

@@ -5 +5 @@
 set (DEMOS
   arg_parser_demo
   graph_to_eps_demo
-  lgf_demo)
+  lgf_demo
+  topological_ordering)
 
 foreach (DEMO_NAME ${DEMOS})
   add_executable (${DEMO_NAME} ${DEMO_NAME}.cc)

demo/Makefile.am

@@ -7 +7 @@
 noinst_PROGRAMS += \
         demo/arg_parser_demo \
         demo/graph_to_eps_demo \
-        demo/lgf_demo
+        demo/lgf_demo \
+        topological_ordering
 
 endif WANT_DEMO
 
 demo_arg_parser_demo_SOURCES = demo/arg_parser_demo.cc
 demo_graph_to_eps_demo_SOURCES = demo/graph_to_eps_demo.cc
 demo_lgf_demo_SOURCES = demo/lgf_demo.cc
+demo_topological_ordering_SOURCES = demo/topological_ordering.cc

new file demo/topological_ordering.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 Dfs class with topological ordering
+///
+/// This demo file shows an example for topological ordering of a
+/// directed acyclic graph (DAG) using \ref lemon::Dfs Dfs algorithm.
+///
+///\include topological_ordering.cc
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <lemon/list_graph.h>
+#include <lemon/graph_utils.h>
+#include <lemon/maps.h>
+#include <lemon/dfs.h>
+
+using namespace lemon;
+
+int main()
+{
+  std::cout << "Topological Ordering Demo" << std::endl;
+
+  // Create and build an acyclic digraph (DAG)
+  ListDigraph gr;
+  ListDigraph::NodeMap<std::string> label(gr);
+  typedef ListDigraph::Node Node;
+
+  // This DAG example for topological ordering is from the book
+  // New Algorithms (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein)
+  {
+    // Create nodes
+    Node belt = gr.addNode();
+    Node trousers = gr.addNode();
+    Node necktie = gr.addNode();
+    Node coat = gr.addNode();
+    Node socks = gr.addNode();
+    Node shirt = gr.addNode();
+    Node shoe = gr.addNode();
+    Node watch = gr.addNode();
+    Node pants = gr.addNode();
+
+    // Set node labels
+    label[belt] = "Belt";
+    label[trousers] = "Trousers";
+    label[necktie] = "Necktie";
+    label[coat] = "Coat";
+    label[socks] = "Socks";
+    label[shirt] = "Shirt";
+    label[shoe] = "Shoe";
+    label[watch] = "Watch";
+    label[pants] = "Pants";
+
+    // Create directed arcs that indicate precedence
+    // (the source must precede the target)
+    gr.addArc(socks, shoe);
+    gr.addArc(pants, shoe);
+    gr.addArc(pants, trousers);
+    gr.addArc(trousers, shoe);
+    gr.addArc(trousers, belt);
+    gr.addArc(belt, coat);
+    gr.addArc(shirt, belt);
+    gr.addArc(shirt, necktie);
+    gr.addArc(necktie, coat);
+  }
+
+  // Run Dfs algorithm and store the nodes in the processing order
+  // using LoggerBoolMap
+  typedef LoggerBoolMap< std::vector<Node>::iterator > StoreMap;
+  std::vector<Node> v(countNodes(gr));
+  StoreMap map(v.begin());
+  Dfs<ListDigraph>::DefProcessedMap<StoreMap>::Create dfs(gr);
+  dfs.processedMap(map).run();
+
+  // Print the nodes of the vector in reverse order, which gives a
+  // topological ordering
+  std::cout << "A possible order to dress up:";
+  for(int i = v.size()-1; i >= 0; --i)
+    std::cout << "  " << label[v[i]];
+  std::cout << std::endl;
+
+  return 0;
+}