ptsp.c

#include<scil/scil.h>
#include<scil/constraints/atour.h>
#include<scil/constraints/path.h>
//#include<scil/constraints/disjunctive.h>
#include<LEDA/tuple.h>
#include<LEDA/stream.h>
#include<fstream.h>

using namespace SCIL;
using namespace LEDA;

typedef two_tuple<node, node> prec;

int main() {

  // READ_GRAPH

  ifstream is("data.sop");

  int i=0, j=0;

  GRAPH<int, int> G;
  node N[1000];
  list<prec> PL;

  while(j<1000) {
    is>>j;
    if(j<1000) {
      N[i]=G.new_node(i);
      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)
            G.new_edge(N[s],N[t], j);
          else PL.append(prec(N[t], N[s]));
        }
        if((s==i-1) || (t==i-1))
          G.new_edge(N[s],N[t], 0);
      }
      cout<<j<<" ";
    };
    is>>j;
    cout<<endl;
  };

  // END_READ_GRAPH

  ILP_Problem IP(Optsense_Min);

  edge e;
  row_map<edge> VM, VM1;
  forall_edges(e, G) {
    VM[e]=IP.add_variable(G[e],0,1, Vartype_Integer);
    if((source(e)!=N[i-1]) && (target(e)!=N[i-1])) 
      VM1[e]=VM[e];
  };

  IP.add_sym_constraint(new ATOUR(G, VM));

  prec p;
  forall(p, PL) {
    IP.add_sym_constraint(new PATH(G, p.first(), p.second(), VM1));
  };

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

  IP.optimize();

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

  // END_SOLUTION
};

---