source: lemon-0.x/demo/simann_maxcut_demo.cc @ 2591:3b4d5bc3b4fb

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2008
 * 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.
 *
 */

/// \ingroup demos
/// \file
/// \brief A program demonstrating the simulated annealing algorithm class.
///
/// This program tries to find a maximal cut in a graph using simulated
/// annealing. It starts from a random solution and then in each step it
/// chooses a node and moves it to the other side of the cut.
///
/// \include simann_maxcut_demo.cc

#include <iostream>
#include <cstdlib>

#include <lemon/simann.h>
#include <lemon/list_graph.h>
#include <lemon/graph_reader.h>

using namespace lemon;

typedef ListGraph Graph;
typedef Graph::Node Node;
typedef Graph::Edge Edge;
typedef Graph::NodeIt NodeIt;
typedef Graph::EdgeIt EdgeIt;
typedef Graph::OutEdgeIt OutEdgeIt;
typedef Graph::InEdgeIt InEdgeIt;

class Entity : public EntityBase
{
  public:
    Graph& g;
    Graph::EdgeMap<int>& w;
    Graph::NodeMap<bool> a;
    int sum;
    Node last_moved;
    Entity(Graph& _g, Graph::EdgeMap<int>& _w) : g(_g), w(_w), a(_g) {}
    double mutate() {
      static const int node_num = countNodes(g);
      int i = 1 + rnd[node_num];
      NodeIt n(g);
      int j = 1;
      while (j < i) {
        ++n;
        ++j;
      }
      for (OutEdgeIt e(g, n); e != INVALID; ++e) {
        if (a[n] != a[g.target(e)]) sum -= w[e];
        if (a[n] == a[g.target(e)]) sum += w[e];
      }
      for (InEdgeIt e(g, n); e != INVALID; ++e) {
        if (a[g.source(e)] != a[n]) sum -= w[e];
        if (a[g.source(e)] == a[n]) sum += w[e];
      }
      bool b = a[n];
      a[n] = !b;
      last_moved = n;
      return -sum;
    }
    void revert() {
      for (OutEdgeIt e(g, last_moved); e != INVALID; ++e) {
        if (a[last_moved] != a[g.target(e)]) sum -= w[e];
        if (a[last_moved] == a[g.target(e)]) sum += w[e];
      }
      for (InEdgeIt e(g, last_moved); e != INVALID; ++e) {
        if (a[g.source(e)] != a[last_moved]) sum -= w[e];
        if (a[g.source(e)] == a[last_moved]) sum += w[e];
      }
      bool b = a[last_moved];
      a[last_moved] = !b;
    }
    Entity* clone() { return new Entity(*this); }
    void randomize() {
      for (NodeIt n(g); n != INVALID; ++n)
        a[n] = false;
      for (NodeIt n(g); n != INVALID; ++n)
        if (rnd.boolean(0.5)) a[n] = true;
      sum = 0;
      for (EdgeIt e(g); e != INVALID; ++e)
        if (a[g.source(e)] != a[g.target(e)])
          sum += w[e];
    }
};

int main()
{
  Graph g;
  Graph::EdgeMap<int> w(g);

  GraphReader<Graph> reader("simann_maxcut_demo.lgf", g);
  reader.readEdgeMap("weight", w);
  reader.run();

  Entity e(g, w);

  SimAnn simann;
  SimpleController ctrl;
  simann.setController(ctrl);
  simann.setEntity(e);
  simann.run();
  
  Entity* be = static_cast<Entity*>(simann.getBestEntity());
  std::cout << be->sum << std::endl;
  for (NodeIt n(g); n != INVALID; ++n)
    if (be->a[n]) std::cout << g.id(n) << ": 1" << std::endl;
    else std::cout << g.id(n) << ": 0" << std::endl;
}