RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

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

 *

 * Copyright (C) 2003-2009

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

 *

 */

#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

  {

    ///File type enum

    enum Type

      {

        NONE, MIN, MAX, SP, MAT

      };

    ///The file type

    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)

        {

        case 'p':

          if(is >> problem >> r.nodeNum >> r.edgeNum)

            {

              getline(is, str);

              r.lineShift++;

              if(problem=="min") r.type=DimacsDescriptor::MIN;

              else if(problem=="max") r.type=DimacsDescriptor::MAX;

              else if(problem=="sp") r.type=DimacsDescriptor::SP;

              else if(problem=="mat") r.type=DimacsDescriptor::MAT;

              else throw FormatError("Unknown problem type");

              return r;

            }

            {

              throw FormatError("Missing or wrong problem type declaration.");

            }

          break;

        case 'c':

          getline(is, str);

          r.lineShift++;

          break;

        default:

          throw FormatError("Unknown DIMACS declaration.");

        }

    throw FormatError("Missing problem type declaration.");

  }

  /// 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,

              dummy<1> = 1)

  {

    g.addArc(s,t);

  }

  /// DIMACS plain (di)graph reader function.

  ///

  /// This function reads a (di)graph without any designated nodes and

  /// maps from DIMACS format, i.e. from DIMACS files having a line

  /// starting with

  /// \code

  ///   p mat

  void readDimacsMat(std::istream& is, Graph &g,

                     DimacsDescriptor desc=DimacsDescriptor())

  {

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

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

      throw FormatError("Problem type mismatch");

    g.clear();

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

    char c;

    int i, j;

    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

        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

  /// starting with

  /// \code

  ///   p mat

  /// \endcode

  /// If \c comment is not empty, then it will be printed in the first line

  /// prefixed by 'c'.

  template<typename Digraph>

  void writeDimacsMat(std::ostream& os, const Digraph &g,

                      std::string comment="") {

    typedef typename Digraph::NodeIt NodeIt;

    typedef typename Digraph::ArcIt ArcIt;

typedef SmartGraph Graph;

template<class Value>

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

              DimacsDescriptor &desc)

{

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

  Digraph g;

  Node s;

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

  Timer t;

  t.restart();

  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)

{

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

  Graph g;

  Timer ti;

  ti.restart();

  readDimacsMat(is, g, desc);

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

  ti.restart();

  MaxMatching<Graph> mat(g);

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

  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;

    }

}

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

  typedef SmartDigraph Digraph;

  typedef Digraph::Arc Arc;

  std::string inputName;

  std::string outputName;

  ArgParser ap(argc, argv);

  ap.other("[INFILE [OUTFILE]]",

           "If either the INFILE or OUTFILE file is missing the standard\n"

           "     input/output will be used instead.")

    .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]);

      }

    case 1:

      input.open(ap.files()[0].c_str());

      if (!input) {

        throw IoError("File cannot be found", ap.files()[0]);

      }

    case 0:

      break;

    default:

      std::cerr << ap.commandName() << ": too many arguments\n";

      return 1;

    }

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

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

      }

    case 1:

      input.open(ap.files()[0].c_str());

      if (!input) {

        throw IoError("File cannot be found", ap.files()[0]);

      }

    case 0:

      break;

    default:

      cerr << ap.commandName() << ": too many arguments\n";

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

        DoubleArcMap capacity(digraph);

        readDimacsSp(is, digraph, capacity, s, desc);

        DigraphWriter<Digraph>(digraph, os).

          arcMap("capacity", capacity).

          node("source", s).

          attribute("problem","sp").

          run();

      }

      break;

    case DimacsDescriptor::MAT:

      {

        Digraph digraph;