Ticket #8317: 0001-Added-edge-coloring-algorithm.patch

new file oost/graph/edge_coloring.hpp

@@ +1 @@
+//=======================================================================
+// Copyright 2013 Maciej Piechotka
+// Authors: Maciej Piechotka
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+#ifndef BOOST_GRAPH_EDGE_COLORING_HPP
+#define BOOST_GRAPH_EDGE_COLORING_HPP
+
+#include <boost/foreach.hpp>
+#include <boost/phoenix.hpp>
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+/* This algorithm is to find coloring of an edges
+
+   Reference:
+
+   Misra, J., & Gries, D. (1992). A constructive proof of Vizing’s
+   theorem. In Information Processing Letters.
+*/
+
+namespace boost {
+  namespace detail {
+    template<typename Graph, typename ColorMap>
+    bool
+    is_free(const Graph &g,
+            ColorMap color_map,
+            typename boost::graph_traits<Graph>::vertex_descriptor u,
+            typename boost::property_traits<ColorMap>::value_type color)
+    {
+      typedef typename boost::property_traits<ColorMap>::value_type color_t;
+      if (color == std::numeric_limits<color_t>::max())
+        return false;
+      BOOST_FOREACH(typename boost::graph_traits<Graph>::edge_descriptor e,
+                    boost::out_edges(u, g)) {
+        if (boost::get(color_map, e) == color) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    template<typename Graph, typename ColorMap>
+    std::vector<typename boost::graph_traits<Graph>::vertex_descriptor>
+    maximal_fan(const Graph &g,
+                ColorMap color_map,
+                typename boost::graph_traits<Graph>::vertex_descriptor x,
+                typename boost::graph_traits<Graph>::vertex_descriptor y)
+    {
+      typedef typename boost::property_traits<ColorMap>::value_type color_t;
+      typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
+      std::vector<vertex_t> fan;
+      fan.push_back(y);
+      bool extended;
+      do {
+        extended = false;
+        BOOST_FOREACH(typename boost::graph_traits<Graph>::edge_descriptor e,
+                      boost::out_edges(x, g)) {
+          vertex_t v = boost::target(e, g);
+          if (is_free(g, color_map, fan.back(), boost::get(color_map, e)) &&
+              std::find(fan.begin(), fan.end(), v) == fan.end()) {
+            fan.push_back(v);
+            extended = true;
+          }
+        }
+      } while(extended);
+      return fan;
+    }
+    template<typename Graph, typename ColorMap>
+    typename boost::property_traits<ColorMap>::value_type
+    find_free_color(const Graph &g,
+                    ColorMap color_map,
+                    typename boost::graph_traits<Graph>::vertex_descriptor u)
+    {
+      typename boost::property_traits<ColorMap>::value_type c = 0;
+      while (!is_free(g, color_map, u, c)) c++;
+      return c;
+    }
+
+    template<typename Graph, typename ColorMap>
+    void
+    invert_cd_path(const Graph &g,
+                   ColorMap color_map,
+                   typename boost::graph_traits<Graph>::vertex_descriptor x,
+                   typename boost::graph_traits<Graph>::edge_descriptor eold,
+                   typename boost::property_traits<ColorMap>::value_type c,
+                   typename boost::property_traits<ColorMap>::value_type d)
+    {
+      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;
+      boost::put(color_map, eold, d);
+      BOOST_FOREACH(edge_t e, boost::out_edges(x, g)) {
+        if (boost::get(color_map, e) == d && e != eold) {
+          invert_cd_path(g, color_map, boost::target(e, g), e, d, c);
+          return;
+        }
+      }
+    }
+
+    template<typename Graph, typename ColorMap>
+    void
+    invert_cd_path(const Graph &g,
+                   ColorMap color_map,
+                   typename boost::graph_traits<Graph>::vertex_descriptor x,
+                   typename boost::property_traits<ColorMap>::value_type c,
+                   typename boost::property_traits<ColorMap>::value_type d)
+    {
+      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;
+      BOOST_FOREACH(edge_t e, boost::out_edges(x, g)) {
+        if (boost::get(color_map, e) == d) {
+          invert_cd_path(g, color_map, boost::target(e, g), e, d, c);
+          return;
+        }
+      }
+    }
+    
+    template<typename Graph, typename ColorMap, typename ForwardIterator>
+    void
+    rotate_fan(const Graph &g,
+               ColorMap color_map,
+               typename boost::graph_traits<Graph>::vertex_descriptor x,
+               ForwardIterator begin,
+               ForwardIterator end)
+    {
+      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;
+      typedef typename boost::property_traits<ColorMap>::value_type color_t;
+      if (begin == end) {
+        return;
+      }
+      edge_t previous = boost::edge(x, *begin, g).first;
+      for (begin++; begin != end; begin++) {
+        edge_t current = boost::edge(x, *begin, g).first;
+        boost::put(color_map, previous, boost::get(color_map, current));
+        previous = current;
+      }
+    }
+  }
+
+  template<typename Graph, typename ColorMap>
+  typename boost::property_traits<ColorMap>::value_type
+  color_edge(const Graph &g,
+             ColorMap color_map,
+             typename boost::graph_traits<Graph>::edge_descriptor e)
+  {
+    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
+    typedef typename boost::property_traits<ColorMap>::value_type color_t;
+    typedef typename std::vector<vertex_t>::iterator fan_iterator;
+    using namespace detail;
+    namespace ph = boost::phoenix;
+    vertex_t x = boost::source(e, g), y = boost::target(e, g);
+    std::vector<vertex_t> fan = maximal_fan(g, color_map, x, y);
+    color_t c = find_free_color(g, color_map, x);
+    color_t d = find_free_color(g, color_map, fan.back());
+    invert_cd_path(g, color_map, x, c, d);
+    fan_iterator w = std::find_if(fan.begin(),
+                                  fan.end(),
+                                  ph::bind(&is_free<Graph, ColorMap>,
+                                           ph::val(g),
+                                           ph::val(color_map),
+                                           ph::arg_names::arg1,
+                                           ph::val(d)));
+    rotate_fan(g, color_map, x, fan.begin(), w + 1);
+    boost::put(color_map, boost::edge(x, *w, g).first, d);
+    return std::max(c, d);
+  }
+
+  template<typename Graph, typename ColorMap>
+  typename boost::property_traits<ColorMap>::value_type
+  edge_coloring(const Graph &g,
+                ColorMap color_map)
+  {
+    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
+    typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;
+    typedef typename boost::property_traits<ColorMap>::value_type color_t;
+    BOOST_FOREACH(edge_t e, boost::edges(g)) {
+      boost::put(color_map, e, std::numeric_limits<color_t>::max());
+    }
+    color_t colors = 0;
+    BOOST_FOREACH(edge_t e, boost::edges(g)) {
+      colors = std::max(colors, color_edge(g, color_map, e) + 1);
+    }
+    return colors;
+  }
+}
+
+#endif