source: lemon-0.x/src/work/marci_max_flow.hh @ 18:7c88989ea45b

#ifndef MARCI_MAX_FLOW_HH
#define MARCI_MAX_FLOW_HH

#include <algorithm>

#include <marci_graph_traits.hh>
#include <marci_property_vector.hh>
#include <marci_bfs.hh>

namespace marci {

  template<typename graph_type, typename T>
  class res_graph_type { 
    typedef typename graph_traits<graph_type>::node_iterator node_iterator;
    typedef typename graph_traits<graph_type>::edge_iterator edge_iterator;
    typedef typename graph_traits<graph_type>::each_node_iterator each_node_iterator;
    typedef typename graph_traits<graph_type>::sym_edge_iterator sym_edge_iterator;

    graph_type& G;
    edge_property_vector<graph_type, T>& flow;
    edge_property_vector<graph_type, T>& capacity;
  public:
    res_graph_type(graph_type& _G, edge_property_vector<graph_type, T>& _flow, edge_property_vector<graph_type, T>& _capacity) : G(_G), flow(_flow), capacity(_capacity) { }

    class res_edge_it {
      friend class res_graph_type<graph_type, T>;
    protected:
      res_graph_type<graph_type, T>* resG;
      sym_edge_iterator sym;
    public:
      res_edge_it() { }
      //bool is_free() {  
      //if (resG->G.a_node(sym)==resG->G.tail(sym)) { 
      //  return (resG->flow.get(sym)<resG->capacity.get(sym)); 
      //} else { 
      //  return (resG->flow.get(sym)>0); 
      //}
      //}
      T free() { 
        if (resG->G.a_node(sym)==resG->G.tail(sym)) { 
          return (resG->capacity.get(sym)-resG->flow.get(sym)); 
        } else { 
          return (resG->flow.get(sym)); 
        }
      }
      bool is_valid() { return sym.is_valid(); }
      void make_invalid() { sym.make_invalid(); }
      void augment(T a) {
        if (resG->G.a_node(sym)==resG->G.tail(sym)) { 
          resG->flow.put(sym, resG->flow.get(sym)+a);
        } else { 
          resG->flow.put(sym, resG->flow.get(sym)-a);
        }
      }
    };

    class res_out_edge_it : public res_edge_it {
    public:
      res_out_edge_it() { }
      res_out_edge_it(res_graph_type<graph_type, T>& _resG, const node_iterator& v) { 
        resG=&_resG;
        sym=resG->G.first_sym_edge(v);
        while( sym.is_valid() && !(free()>0) ) { ++sym; }
      }
      res_out_edge_it& operator++() { 
        ++sym; 
        while( sym.is_valid() && !(free()>0) ) { ++sym; }
        return *this; 
      }
    };

    res_out_edge_it first_out_edge(const node_iterator& v) {
      return res_out_edge_it(*this, v);
    }

    each_node_iterator first_node() {
      return G.first_node();
    }

    node_iterator tail(const res_edge_it& e) { return G.a_node(e.sym); }
    node_iterator head(const res_edge_it& e) { return G.b_node(e.sym); }

    int id(const node_iterator& v) { return G.id(v); }

    //node_iterator invalid_node() { return G.invalid_node(); }
    //res_edge_it invalid_edge() { res_edge_it n; n.sym=G.invalid_sym_edge(); return n; }
    
  };

  template <typename graph_type, typename T>
  struct graph_traits< res_graph_type<graph_type, T> > {
    typedef typename graph_traits<graph_type>::node_iterator node_iterator;
    typedef typename res_graph_type<graph_type, T>::res_edge_it edge_iterator;
    typedef typename graph_traits<graph_type>::each_node_iterator each_node_iterator;
    typedef typename res_graph_type<graph_type, T>::res_out_edge_it out_edge_iterator;
  };

  template <typename graph_type, typename T>
  struct max_flow_type {
    
    typedef typename graph_traits<graph_type>::node_iterator node_iterator;
    typedef typename graph_traits<graph_type>::edge_iterator edge_iterator;
    typedef typename graph_traits<graph_type>::each_node_iterator each_node_iterator;
    typedef typename graph_traits<graph_type>::out_edge_iterator out_edge_iterator;
    typedef typename graph_traits<graph_type>::in_edge_iterator in_edge_iterator;

    graph_type& G;
    node_iterator s;
    node_iterator t;
    edge_property_vector<graph_type, T> flow;
    edge_property_vector<graph_type, T>& capacity;

    max_flow_type(graph_type& _G, node_iterator _s, node_iterator _t, edge_property_vector<graph_type, T>& _capacity) : G(_G), s(_s), t(_t), flow(_G), capacity(_capacity) { 
      for(each_node_iterator i=G.first_node(); i.is_valid(); ++i) 
        for(out_edge_iterator j=G.first_out_edge(i); j.is_valid(); ++j) 
          flow.put(j, 0);
    }
    void run() {
      typedef res_graph_type<graph_type, T> aug_graph_type;
      aug_graph_type res_graph(G, flow, capacity);

      bool augment;
      do {
        augment=false;

        typedef std::queue<graph_traits<aug_graph_type>::out_edge_iterator> bfs_queue_type;
        bfs_queue_type bfs_queue;
        bfs_queue.push(res_graph.first_out_edge(s));

        typedef node_property_vector<aug_graph_type, bool> reached_type;
        reached_type reached(res_graph, false);
        reached.put(s, true); 
        
        bfs_iterator1< aug_graph_type, reached_type > 
        res_bfs(res_graph, bfs_queue, reached);

        typedef node_property_vector<aug_graph_type, graph_traits<aug_graph_type>::edge_iterator> pred_type;
        pred_type pred(res_graph);
        graph_traits<aug_graph_type>::edge_iterator a; 
        a.make_invalid();
        pred.put(s, a);

        typedef node_property_vector<aug_graph_type, int> free_type;
        free_type free(res_graph);
        
        //searching for augmenting path
        while ( res_bfs.is_valid() ) { 
          //std::cout<<"KULSO ciklus itt jar: "<<G.id(res_graph.tail(res_bfs))<<"->"<<G.id(res_graph.head(res_bfs))<<std::endl;
          if (res_bfs.is_newly_reached()) {
            graph_traits<aug_graph_type>::edge_iterator e;
            e=res_bfs;
            node_iterator v=res_graph.tail(e);
            node_iterator w=res_graph.head(e);
            //std::cout<<G.id(v)<<"->"<<G.id(w)<<", "<<G.id(w)<<" is newly reached";
            pred.put(w, e);
            if (pred.get(v).is_valid()) {
              free.put(w, std::min(free.get(v), e.free()));
              //std::cout <<" nem elso csucs: ";
              //std::cout <<"szabad kap eddig: "<< free.get(w) << " ";
            } else {
              free.put(w, e.free()); 
              //std::cout <<" elso csucs: ";
              //std::cout <<"szabad kap eddig: "<< free.get(w) << " ";
            }
            //std::cout<<std::endl;
          }
        
          if (res_graph.head(res_bfs)==t) break;
          ++res_bfs;
        }
        if (reached.get(t)) {
          augment=true;
          node_iterator n=t;
          T augment_value=free.get(t);
          std::cout<<"augmentation: ";
          while (pred.get(n).is_valid()) { 
            graph_traits<aug_graph_type>::edge_iterator e=pred.get(n);
            e.augment(augment_value); 
            std::cout<<"("<<res_graph.tail(e)<< "->"<<res_graph.head(e)<<") ";
            n=res_graph.tail(e);
          }
          std::cout<<std::endl;
        }

        std::cout << "actual flow: "<< std::endl;
        for(graph_traits<graph_type>::each_edge_iterator e=G.first_edge(); e.is_valid(); ++e) { 
          std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
        }
        std::cout<<std::endl;

      } while (augment);
    }
  };

} // namespace marci

#endif //MARCI_MAX_FLOW_HH