/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2006

  * 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 Coloring of a graph.

 ///

 /// This example shows how can we color the nodes of a planar graph efficiently

 /// with six colors.

 ///

 /// \include coloring.cc

 #include <vector>

 #include <iostream>

 #include <lemon/smart_graph.h>

 #include <lemon/bucket_heap.h>

 #include <lemon/graph_reader.h>

 #include <lemon/graph_to_eps.h>

 #include <fstream>

 using namespace std;

 using namespace lemon;

 int main() {

   typedef SmartUGraph Graph;

   typedef Graph::Node Node;

   typedef Graph::NodeIt NodeIt;

   typedef Graph::UEdge UEdge;

   typedef Graph::IncEdgeIt IncEdgeIt;

   std::cout << "Six coloring of a planar graph" << std::endl;

   std::cout << "Input file: coloring.lgf" << std::endl;

   std::cout << "Output file: coloring.eps" << std::endl;

   Graph graph;

   UGraphReader<Graph> reader("coloring.lgf", graph);

   Graph::NodeMap<dim2::Point<double> > coords(graph);

   reader.readNodeMap("coords", coords);

   reader.run();

   Graph::NodeMap<int> color(graph, -2);

   Graph::NodeMap<int> heapMap(graph, -1);

   BucketHeap<Node, Graph::NodeMap<int> > heap(heapMap);

   for (NodeIt it(graph); it != INVALID; ++it) {

     heap.push(it, countOutEdges(graph, it));

   }

   vector<Node> order;

   while (!heap.empty()) {

     Node node = heap.top();

     heap.pop();

     color[node] = -1;

     order.push_back(node);

     for (IncEdgeIt it(graph, node); it != INVALID; ++it) {

       Node target = graph.runningNode(it); 

       if (color[target] == -2) {

 	heap.decrease(target, heap[target] - 1);

       }

     }

   }

   for (int i = order.size() - 1; i >= 0; --i) {

     set<int> forbidden;

     for (IncEdgeIt it(graph, order[i]); it != INVALID; ++it) {

       Node target = graph.runningNode(it); 

       if (color[target] != -1) {

 	forbidden.insert(color[target]);

       }

     }

     int current = 0;

     while (forbidden.find(current) != forbidden.end()) ++current;

     color[order[i]] = current;

   }

   Palette palette;

   graphToEps(graph, "coloring.eps").

     title("Six Colored Plan Graph").copyright("(C) 2006 LEMON Project").

     coords(coords).nodeColors(composeMap(palette, color)).

     nodeScale(5.0).scaleToA4().run();

   return 0;

 }