ptsp.cc

#include<scil/scil.h>
#include<scil/constraints/atour.h>
#include<scil/constraints/path.h>
#include<boost/foreach.hpp>
#include<boost/graph/iteration_macros.hpp>
#include<fstream>

using namespace SCIL;
using namespace boost;

typedef boost::adjacency_list<vecS,vecS,bidirectionalS,no_property,property<edge_weight_t,int> > Graph;
typedef boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef boost::graph_traits<Graph>::edge_iterator edge_iter;


typedef std::pair<vertex_descriptor,vertex_descriptor> prec;

int main(int argc, char **argv) {

  // READ_GRAPH
  const char* fname = (argc > 1) ? argv[1] : "data.sop";
  ifstream is(fname);

  int i=0, j=0;

  Graph G;

  vertex_descriptor V[1000];
  std::list<prec> PL;

  while(j<1000) {
    is>>j;
    if(j<1000) {
      V[i] = add_vertex(G);
      i++;
    }
  };
  is>>j;

  for(int s=0; s<i; s++) {
    for(int t=0; t<i; t++) {
      is>>j;
      if(s!=t) {
        if((s!=i-1) && (t!=i-1)) {
          if(j>=0)
            add_edge(V[s],V[t],j,G);
          else PL.push_back(prec(V[t], V[s]));
        }
        if((s==i-1) || (t==i-1))
          add_edge(V[s],V[t],0,G);
      }
      cout<<j<<" ";
    };
    is>>j;
    cout<<endl;
  };

  // END_READ_GRAPH

  ILP_Problem IP(Optsense_Min);

  var_map<edge_descriptor> VM, VM1;

  property_map<Graph, edge_weight_t>::type w
  = get(edge_weight, G);


  BGL_FORALL_EDGES(e,G,Graph) {
    VM[e]=IP.add_binary_variable(w[e]);                 
    if( (source(e,G)!=V[i-1]) && (target(e,G)!=V[i-1]))
      VM1[e]=VM[e];
  }


  //FIXME
  IP.add_sym_constraint(new ATOUR<Graph>(G, VM));


  prec p;
  std::list< PATH<Graph>* > paths;

  BOOST_FOREACH(p, PL) {
    IP.add_sym_constraint(new PATH<Graph>(G, p.first, p.second, VM1));
  };

  //IP.add_sym_constraint(new disjunctive()); 

  IP.optimize();

  BGL_FORALL_EDGES(e,G,Graph) 
    if(IP.get_solution(VM[e])==1) 
      cout << source(e,G) << " " << target(e,G) << " edge\n";

};

---