path.h

#ifndef PATH_CONSTRAINT_H
#define PATH_CONSTRAINT_H

#include <scil/scil.h>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/boykov_kolmogorov_max_flow.hpp>
#include <boost/graph/depth_first_search.hpp>
#include <boost/graph/iteration_macros.hpp>

using namespace boost;

namespace SCIL {

template< typename Graph >
class PATH : public sym_constraint { 
   private:
      typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex; 
      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_descriptor; 

      typedef adjacency_list_traits < vecS, vecS, bidirectionalS > Traits;
      typedef adjacency_list < vecS, vecS, bidirectionalS,
        property < vertex_name_t, std::string,
        property < vertex_index_t, long> >,
    
        property < edge_capacity_t, long,
        property < edge_residual_capacity_t, long,
        property < edge_reverse_t, Traits::edge_descriptor > > > > dGraph;



      typedef typename graph_traits<dGraph>::vertex_descriptor dvertex;
      typedef typename graph_traits<dGraph>::edge_descriptor dedge;

      dGraph H;         
      Graph& G;         
      vertex u, v;      

      std::map<edge_descriptor,dedge> GtoH;

      var_map<edge_descriptor>& VM;    

   class path_cutset_inequality;

   public:

     PATH(Graph& G, vertex u, vertex v, var_map<edge_descriptor>& X);

     status standard_separation(subproblem& S);

     status feasible(solution& S);

      void info();

    private:
     void dfs(dGraph& G, dvertex u, std::vector<bool>& R);

};

}

// Load implementation
#include <../src/constraints/path.cc>

#endif

---