/* -*- 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 Demonstrating the Dfs class with topological ordering

///

///\include topological_ordering.cc

#include <iostream>

#include <string>

#include <list>

#include <lemon/list_graph.h>

#include <lemon/maps.h>

#include <lemon/dfs.h>

using namespace lemon;

template< typename GR >

class SerializingWriteMap

{

public:

  typedef typename GR::Node  Key;

  typedef bool  Value;

  typedef std::list<Key>  OrderedList;

  OrderedList  order;

  SerializingWriteMap( const GR& gr ) {}

  void  set( const Key& k, const Value& v ) {

    if( v ) order.push_front(k);

  }

  Value  operator[] ( const Key& ) {

    return false;

  }

};

int  main( int argc, char *argv[] )

{

  std::cout << "Topological Ordering demo" << std::endl;

  // Create and build the graph

  ListGraph  gr;

  ListGraph::NodeMap<std::string>  label(gr);

  typedef ListGraph::Node  Node;

  // This DAG example for topological ordering is from the book New Algorithms

  // (Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein)

  {

    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();

    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";

    // Here we use a directed edge to indicate precedenc.

    // The source must precede the target.

    gr.addEdge( socks, shoe );

    gr.addEdge( pants, shoe );

    gr.addEdge( pants, trousers );

    gr.addEdge( trousers, shoe );

    gr.addEdge( trousers, belt );

    gr.addEdge( belt, coat );

    gr.addEdge( shirt, belt );

    gr.addEdge( shirt, necktie );

    gr.addEdge( necktie, coat );

  }

  // Calculate topological order

  Dfs<ListGraph, Dfs<ListGraph>::DefProcessedMapTraits<SerializingWriteMap<ListGraph> > >  dfs(gr);

  SerializingWriteMap<ListGraph>  list(gr);

  dfs.processedMap(list);

  dfs.run();

  // Write out the result

  std::cout << "One possible order to dress up:";

  for( SerializingWriteMap<ListGraph>::OrderedList::iterator  it = list.order.begin(); it != list.order.end(); ++it )

    std::cout << "  " << label[*it];

  std::cout << std::endl;

  return 0;

}