RhodeCode

 * 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.

 *

 */

#ifndef LEMON_DIMACS_H

#define LEMON_DIMACS_H

#include <iostream>

#include <string>

#include <vector>

#include <lemon/maps.h>

#include <lemon/error.h>

/// \ingroup dimacs_group

/// \file

/// \brief DIMACS file format reader.

namespace lemon {

  /// \addtogroup dimacs_group

  /// @{

  /// DIMACS file type descriptor.

  struct DimacsDescriptor

  {

    Type type;

    ///The number of nodes in the graph

    int nodeNum;

    ///The number of edges in the graph

    int edgeNum;

    int lineShift;

    /// Constructor. Sets the type to NONE.

    DimacsDescriptor() : type(NONE) {}

  };

  ///Discover the type of a DIMACS file

  ///and size info. The found data is returned in a special struct

  ///that can be evaluated and passed to the appropriate reader

  ///function.

  DimacsDescriptor dimacsType(std::istream& is)

  {

    DimacsDescriptor r;

    std::string problem,str;

    char c;

    r.lineShift=0;

    while (is >> c)

      switch(c)

        {

  }

  /// DIMACS minimum cost flow reader function.

  ///

  /// This function reads a minimum cost flow instance from DIMACS format,

  /// i.e. from a DIMACS file having a line starting with

  /// \code

  ///   p min

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The supply

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template <typename Digraph, typename LowerMap,

            typename CapacityMap, typename CostMap,

            typename SupplyMap>

  void readDimacsMin(std::istream& is,

                     Digraph &g,

                     LowerMap& lower,

                     CapacityMap& capacity,

                     CostMap& cost,

                     SupplyMap& supply,

                     DimacsDescriptor desc=DimacsDescriptor())

  {

    g.clear();

    std::vector<typename Digraph::Node> nodes;

    typename Digraph::Arc e;

    std::string problem, str;

    char c;

    int i, j;

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

    if(desc.type!=DimacsDescriptor::MIN)

      throw FormatError("Problem type mismatch");

    nodes.resize(desc.nodeNum + 1);

    for (int k = 1; k <= desc.nodeNum; ++k) {

      nodes[k] = g.addNode();

      supply.set(nodes[k], 0);

    }

    typename SupplyMap::Value sup;

    typename CapacityMap::Value low;

    typename CapacityMap::Value cap;

    typename CostMap::Value co;

    while (is >> c) {

      switch (c) {

      case 'c': // comment line

        getline(is, str);

        break;

      case 'n': // node definition line

        is >> i >> sup;

        getline(is, str);

        supply.set(nodes[i], sup);

        break;

        is >> i >> j >> low >> cap >> co;

        getline(is, str);

        e = g.addArc(nodes[i], nodes[j]);

        lower.set(e, low);

          capacity.set(e, cap);

        else

        cost.set(e, co);

        break;

      }

    }

  }

  template<typename Digraph, typename CapacityMap>

  void _readDimacs(std::istream& is,

                   Digraph &g,

                   CapacityMap& capacity,

                   typename Digraph::Node &s,

                   typename Digraph::Node &t,

                   DimacsDescriptor desc=DimacsDescriptor()) {

    g.clear();

    s=t=INVALID;

    std::vector<typename Digraph::Node> nodes;

    typename Digraph::Arc e;

    char c, d;

    int i, j;

    typename CapacityMap::Value _cap;

    std::string str;

    nodes.resize(desc.nodeNum + 1);

    for (int k = 1; k <= desc.nodeNum; ++k) {

      nodes[k] = g.addNode();

    }

    while (is >> c) {

      switch (c) {

      case 'c': // comment line

        getline(is, str);

        break;

      case 'n': // node definition line

        if (desc.type==DimacsDescriptor::SP) { // shortest path problem

          is >> i;

          getline(is, str);

          s = nodes[i];

        }

        if (desc.type==DimacsDescriptor::MAX) { // max flow problem

          is >> i >> d;

          getline(is, str);

          if (d == 's') s = nodes[i];

          if (d == 't') t = nodes[i];

        }

        break;

          is >> i >> j >> _cap;

          getline(is, str);

          e = g.addArc(nodes[i], nodes[j]);

          capacity.set(e, _cap);

          is >> i >> j;

          getline(is, str);

          g.addArc(nodes[i], nodes[j]);

        }

        break;

      }

    }

  }

  /// DIMACS maximum flow reader function.

  ///

  /// This function reads a maximum flow instance from DIMACS format,

  /// i.e. from a DIMACS file having a line starting with

  /// \code

  ///   p max

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The arc

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template<typename Digraph, typename CapacityMap>

  void readDimacsMax(std::istream& is,

                     Digraph &g,

                     CapacityMap& capacity,

                     typename Digraph::Node &s,

                     typename Digraph::Node &t,

                     DimacsDescriptor desc=DimacsDescriptor()) {

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

    if(desc.type!=DimacsDescriptor::MAX)

      throw FormatError("Problem type mismatch");

  }

  /// DIMACS shortest path reader function.

  ///

  /// This function reads a shortest path instance from DIMACS format,

  /// i.e. from a DIMACS file having a line starting with

  /// \code

  ///   p sp

  /// \endcode

  /// At the beginning, \c g is cleared by \c g.clear(). The arc

  /// source node.

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template<typename Digraph, typename LengthMap>

  void readDimacsSp(std::istream& is,

                    Digraph &g,

                    LengthMap& length,

                    typename Digraph::Node &s,

                    DimacsDescriptor desc=DimacsDescriptor()) {

    typename Digraph::Node t;

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

    if(desc.type!=DimacsDescriptor::SP)

      throw FormatError("Problem type mismatch");

  }

  /// DIMACS capacitated digraph reader function.

  ///

  /// This function reads an arc capacitated digraph instance from

  /// At the beginning, \c g is cleared by \c g.clear()

  ///

  /// If the file type was previously evaluated by dimacsType(), then

  /// the descriptor struct should be given by the \c dest parameter.

  template<typename Digraph, typename CapacityMap>

  void readDimacsCap(std::istream& is,

                     Digraph &g,

                     CapacityMap& capacity,

                     DimacsDescriptor desc=DimacsDescriptor()) {

    typename Digraph::Node u,v;

    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);

    if(desc.type!=DimacsDescriptor::MAX || desc.type!=DimacsDescriptor::SP)

      throw FormatError("Problem type mismatch");

  }

  template<typename Graph>

  typename enable_if<lemon::UndirectedTagIndicator<Graph>,void>::type

  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,

              dummy<0> = 0)

  {

    g.addEdge(s,t);

  }

  template<typename Graph>

  typename disable_if<lemon::UndirectedTagIndicator<Graph>,void>::type

  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,

    nodes.resize(desc.nodeNum + 1);

    for (int k = 1; k <= desc.nodeNum; ++k) {

      nodes[k] = g.addNode();

    }

    while (is >> c) {

      switch (c) {

      case 'c': // comment line

        getline(is, str);

        break;

      case 'n': // node definition line

        break;

        is >> i >> j;

        getline(is, str);

        _addArcEdge(g,nodes[i], nodes[j]);

        break;

      }

    }

  }

  /// DIMACS plain digraph writer function.

  ///

  /// This function writes a digraph without any designated nodes and

  /// maps into DIMACS format, i.e. into DIMACS file having a line

  readDimacsSp(is, g, len, s, desc);

  if(report) std::cerr << "Read the file: " << t << '\n';

  t.restart();

  Dijkstra<Digraph, Digraph::ArcMap<Value> > dij(g,len);

  if(report) std::cerr << "Setup Dijkstra class: " << t << '\n';

  t.restart();

  dij.run(s);

  if(report) std::cerr << "Run Dijkstra: " << t << '\n';

}

template<class Value>

void solve_max(ArgParser &ap, std::istream &is, std::ostream &,

{

  bool report = !ap.given("q");

  Digraph g;

  Node s,t;

  Digraph::ArcMap<Value> cap(g);

  Timer ti;

  ti.restart();

  if(report) std::cerr << "Read the file: " << ti << '\n';

  ti.restart();

  Preflow<Digraph, Digraph::ArcMap<Value> > pre(g,cap,s,t);

  if(report) std::cerr << "Setup Preflow class: " << ti << '\n';

  ti.restart();

  pre.run();

  if(report) std::cerr << "Run Preflow: " << ti << '\n';

  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  

}

void solve_mat(ArgParser &ap, std::istream &is, std::ostream &,

              DimacsDescriptor &desc)

  ti.restart();

  mat.run();

  if(report) std::cerr << "Run MaxMatching: " << ti << '\n';

  if(report) std::cerr << "\nCardinality of max matching: "

                       << mat.matchingSize() << '\n';  

}

template<class Value>

void solve(ArgParser &ap, std::istream &is, std::ostream &os,

           DimacsDescriptor &desc)

{

  switch(desc.type)

    {

    case DimacsDescriptor::MIN:

      std::cerr <<

        "\n\n Sorry, the min. cost flow solver is not yet available.\n";

      break;

    case DimacsDescriptor::MAX:

      break;

    case DimacsDescriptor::SP:

      solve_sp<Value>(ap,is,os,desc);

      break;

    case DimacsDescriptor::MAT:

      solve_mat(ap,is,os,desc);

      break;

    default:

      break;

    }

}

    .boolOption("q", "Do not print any report")

    .boolOption("int","Use 'int' for capacities, costs etc. (default)")

    .optionGroup("datatype","int")

#ifdef HAVE_LONG_LONG

    .boolOption("long","Use 'long long' for capacities, costs etc.")

    .optionGroup("datatype","long")

#endif

    .boolOption("double","Use 'double' for capacities, costs etc.")

    .optionGroup("datatype","double")

    .boolOption("ldouble","Use 'long double' for capacities, costs etc.")

    .optionGroup("datatype","ldouble")

    .onlyOneGroup("datatype")

    .run();

  std::ifstream input;

  std::ofstream output;

  switch(ap.files().size())

    {

    case 2:

      output.open(ap.files()[1].c_str());

      if (!output) {

        throw IoError("Cannot open the file for writing", ap.files()[1]);

      }

  }

  istream& is = (ap.files().size()<1 ? cin : input);

  ostream& os = (ap.files().size()<2 ? cout : output);

  DimacsDescriptor desc = dimacsType(is);

  switch(desc.type)

    {

    case DimacsDescriptor::MIN:

      {

        Digraph digraph;

        DoubleArcMap lower(digraph), capacity(digraph), cost(digraph);

        DoubleNodeMap supply(digraph);

        DigraphWriter<Digraph>(digraph, os).

          nodeMap("supply", supply).

          arcMap("lower", lower).

          arcMap("capacity", capacity).

          arcMap("cost", cost).

          attribute("problem","min").

          run();

      }

      break;

    case DimacsDescriptor::MAX:

      {

        Digraph digraph;

        Node s, t;

        DoubleArcMap capacity(digraph);

        DigraphWriter<Digraph>(digraph, os).

          arcMap("capacity", capacity).

          node("source", s).

          node("target", t).

          attribute("problem","max").

          run();

      }

      break;

    case DimacsDescriptor::SP:

      {

        Digraph digraph;

        Node s;