RhodeCode

      _node_num = countNodes(_graph);

      _arc_num = countArcs(_graph);

      _res_node_num = _node_num + 1;

      _res_arc_num = 2 * (_arc_num + _node_num);

      _root = _node_num;

      _first_out.resize(_res_node_num + 1);

      _forward.resize(_res_arc_num);

      _source.resize(_res_arc_num);

      _target.resize(_res_arc_num);

      _reverse.resize(_res_arc_num);

      _lower.resize(_res_arc_num);

      _upper.resize(_res_arc_num);

      _scost.resize(_res_arc_num);

      _supply.resize(_res_node_num);

      _res_cap.resize(_res_arc_num);

      _cost.resize(_res_arc_num);

      _pi.resize(_res_node_num);

      _excess.resize(_res_node_num);

      _next_out.resize(_res_node_num);

      _arc_vec.reserve(_res_arc_num);

      _cost_vec.reserve(_res_arc_num);

      // Copy the graph

      int i = 0, j = 0, k = 2 * _arc_num + _node_num;

      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

        _node_id[n] = i;

      }

      i = 0;

      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {

        _first_out[i] = j;

        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {

          _arc_idf[a] = j;

          _forward[j] = true;

          _source[j] = i;

          _target[j] = _node_id[_graph.runningNode(a)];

        }

        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {

          _arc_idb[a] = j;

          _forward[j] = false;

          _source[j] = i;

          _target[j] = _node_id[_graph.runningNode(a)];

        }

        _forward[j] = false;

        _source[j] = i;

        _target[j] = _root;

        _reverse[j] = k;

        _forward[k] = true;

        _source[k] = _root;

        _target[k] = i;

        _reverse[k] = j;

        ++j; ++k;

      }

      _first_out[i] = j;

      _first_out[_res_node_num] = k;

      for (ArcIt a(_graph); a != INVALID; ++a) {

        int fi = _arc_idf[a];

        int bi = _arc_idb[a];

        _reverse[fi] = bi;

        _reverse[bi] = fi;

      }

      // Reset parameters

      resetParams();

      return *this;

    }

    /// @}

    /// \name Query Functions

    /// The results of the algorithm can be obtained using these

    /// functions.\n

    /// The \ref run() function must be called before using them.

    /// @{

    /// \brief Return the total cost of the found flow.

    ///

    /// This function returns the total cost of the found flow.

    /// Its complexity is O(e).

    ///

    /// \note The return type of the function can be specified as a

    /// template parameter. For example,

    /// \code

    ///   cs.totalCost<double>();

    /// \endcode

    /// It is useful if the total cost cannot be stored in the \c Cost

    /// type of the algorithm, which is the default return type of the

    /// function.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename Number>

    Number totalCost() const {

      Number c = 0;

      for (ArcIt a(_graph); a != INVALID; ++a) {

        int i = _arc_idb[a];

        c += static_cast<Number>(_res_cap[i]) *

             (-static_cast<Number>(_scost[i]));

      }

      return c;

    }

#ifndef DOXYGEN

    Cost totalCost() const {

      return totalCost<Cost>();

    }

#endif

    /// \brief Return the flow on the given arc.

    ///

    /// This function returns the flow on the given arc.

    ///

    /// \pre \ref run() must be called before using this function.

    Value flow(const Arc& a) const {

      return _res_cap[_arc_idb[a]];

    }

    /// \brief Return the flow map (the primal solution).

    ///

    /// This function copies the flow value on each arc into the given

    /// map. The \c Value type of the algorithm must be convertible to

    /// the \c Value type of the map.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename FlowMap>

    void flowMap(FlowMap &map) const {

      for (ArcIt a(_graph); a != INVALID; ++a) {

        map.set(a, _res_cap[_arc_idb[a]]);

      }

    }

    /// \brief Return the potential (dual value) of the given node.

    ///

    /// This function returns the potential (dual value) of the

    /// given node.

    ///

    /// \pre \ref run() must be called before using this function.

    Cost potential(const Node& n) const {

      return static_cast<Cost>(_pi[_node_id[n]]);

    }

    /// \brief Return the potential map (the dual solution).

    ///

    /// This function copies the potential (dual value) of each node

    /// into the given map.

    /// The \c Cost type of the algorithm must be convertible to the

    /// \c Value type of the map.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename PotentialMap>

    void potentialMap(PotentialMap &map) const {

      for (NodeIt n(_graph); n != INVALID; ++n) {

        map.set(n, static_cast<Cost>(_pi[_node_id[n]]));

      }

    }

    /// @}

  private:

    // Initialize the algorithm

    ProblemType init() {

      if (_res_node_num <= 1) return INFEASIBLE;

      // Check the sum of supply values

      _sum_supply = 0;

      for (int i = 0; i != _root; ++i) {

        _sum_supply += _supply[i];

      }

      if (_sum_supply > 0) return INFEASIBLE;

      // Initialize vectors

      for (int i = 0; i != _res_node_num; ++i) {

        _pi[i] = 0;

        _excess[i] = _supply[i];

      }

      // Remove infinite upper bounds and check negative arcs

      const Value MAX = std::numeric_limits<Value>::max();

      int last_out;

      if (_have_lower) {

        for (int i = 0; i != _root; ++i) {

          last_out = _first_out[i+1];

          for (int j = _first_out[i]; j != last_out; ++j) {

            if (_forward[j]) {

              Value c = _scost[j] < 0 ? _upper[j] : _lower[j];

              if (c >= MAX) return UNBOUNDED;

              _excess[i] -= c;

              _excess[_target[j]] += c;

            }

          }

        }

      } else {

        for (int i = 0; i != _root; ++i) {

          last_out = _first_out[i+1];

          for (int j = _first_out[i]; j != last_out; ++j) {

            if (_forward[j] && _scost[j] < 0) {

              Value c = _upper[j];

              if (c >= MAX) return UNBOUNDED;

              _excess[i] -= c;

              _excess[_target[j]] += c;

            }

          }

        }

      }

      Value ex, max_cap = 0;

      for (int i = 0; i != _res_node_num; ++i) {

        ex = _excess[i];

        _excess[i] = 0;

        if (ex < 0) max_cap -= ex;

      }

      for (int j = 0; j != _res_arc_num; ++j) {

        if (_upper[j] >= MAX) _upper[j] = max_cap;

      }

      // Initialize the large cost vector and the epsilon parameter

      _epsilon = 0;

      LargeCost lc;

      for (int i = 0; i != _root; ++i) {

        last_out = _first_out[i+1];

        for (int j = _first_out[i]; j != last_out; ++j) {

          lc = static_cast<LargeCost>(_scost[j]) * _res_node_num * _alpha;

          _cost[j] = lc;

          if (lc > _epsilon) _epsilon = lc;

        }

      }

      _epsilon /= _alpha;

      // Initialize maps for Circulation and remove non-zero lower bounds

      ConstMap<Arc, Value> low(0);

      typedef typename Digraph::template ArcMap<Value> ValueArcMap;

      typedef typename Digraph::template NodeMap<Value> ValueNodeMap;

      ValueArcMap cap(_graph), flow(_graph);

      ValueNodeMap sup(_graph);

      for (NodeIt n(_graph); n != INVALID; ++n) {

        sup[n] = _supply[_node_id[n]];

      }

      if (_have_lower) {

        for (ArcIt a(_graph); a != INVALID; ++a) {

          int j = _arc_idf[a];

          Value c = _lower[j];

          cap[a] = _upper[j] - c;

          sup[_graph.source(a)] -= c;

          sup[_graph.target(a)] += c;

        }

      } else {

        for (ArcIt a(_graph); a != INVALID; ++a) {

          cap[a] = _upper[_arc_idf[a]];

        }

      }

      _sup_node_num = 0;

      for (NodeIt n(_graph); n != INVALID; ++n) {

        if (sup[n] > 0) ++_sup_node_num;

      }

      // Find a feasible flow using Circulation

      Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>

        circ(_graph, low, cap, sup);

      if (!circ.flowMap(flow).run()) return INFEASIBLE;

      // Set residual capacities and handle GEQ supply type

      if (_sum_supply < 0) {

        for (ArcIt a(_graph); a != INVALID; ++a) {

          Value fa = flow[a];

          _res_cap[_arc_idf[a]] = cap[a] - fa;

          _res_cap[_arc_idb[a]] = fa;

          sup[_graph.source(a)] -= fa;

          sup[_graph.target(a)] += fa;

        }

        for (NodeIt n(_graph); n != INVALID; ++n) {

          _excess[_node_id[n]] = sup[n];

        }

        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {

          int u = _target[a];

          int ra = _reverse[a];

          _res_cap[a] = -_sum_supply + 1;

          _res_cap[ra] = -_excess[u];

          _cost[a] = 0;

          _cost[ra] = 0;

          _excess[u] = 0;

        }

      } else {

        for (ArcIt a(_graph); a != INVALID; ++a) {

          Value fa = flow[a];

          _res_cap[_arc_idf[a]] = cap[a] - fa;

          _res_cap[_arc_idb[a]] = fa;

        }

        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {

          int ra = _reverse[a];

          _res_cap[a] = 0;

          _res_cap[ra] = 0;

          _cost[a] = 0;

          _cost[ra] = 0;

        }

      }

      // Initialize data structures for buckets

      _max_rank = _alpha * _res_node_num;

      _buckets.resize(_max_rank);

      _bucket_next.resize(_res_node_num + 1);

      _bucket_prev.resize(_res_node_num + 1);

      _rank.resize(_res_node_num + 1);

      return OPTIMAL;

    }

    // Execute the algorithm and transform the results

    void start(Method method) {

      const int MAX_PARTIAL_PATH_LENGTH = 4;

      switch (method) {

        case PUSH:

          startPush();

          break;

        case AUGMENT:

          startAugment(_res_node_num - 1);

          break;

        case PARTIAL_AUGMENT:

          startAugment(MAX_PARTIAL_PATH_LENGTH);

          break;

      }

      // Compute node potentials for the original costs

      _arc_vec.clear();

      _cost_vec.clear();

      for (int j = 0; j != _res_arc_num; ++j) {

        if (_res_cap[j] > 0) {

          _arc_vec.push_back(IntPair(_source[j], _target[j]));

          _cost_vec.push_back(_scost[j]);

        }

      }

      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());

      typename BellmanFord<StaticDigraph, LargeCostArcMap>

        ::template SetDistMap<LargeCostNodeMap>::Create bf(_sgr, _cost_map);

      bf.distMap(_pi_map);

      bf.init(0);

      bf.start();

      // Handle non-zero lower bounds

      if (_have_lower) {

        int limit = _first_out[_root];

        for (int j = 0; j != limit; ++j) {

          if (!_forward[j]) _res_cap[j] += _lower[j];

        }

      }

    }

    // Initialize a cost scaling phase

    void initPhase() {

      // Saturate arcs not satisfying the optimality condition

      for (int u = 0; u != _res_node_num; ++u) {

        int last_out = _first_out[u+1];

        LargeCost pi_u = _pi[u];

        for (int a = _first_out[u]; a != last_out; ++a) {

          Value delta = _res_cap[a];

          if (delta > 0) {

            int v = _target[a];

            if (_cost[a] + pi_u - _pi[v] < 0) {

              _excess[u] -= delta;

              _excess[v] += delta;

              _res_cap[a] = 0;

              _res_cap[_reverse[a]] += delta;

            }

          }

        }

      }

      // Find active nodes (i.e. nodes with positive excess)

      for (int u = 0; u != _res_node_num; ++u) {

        if (_excess[u] > 0) _active_nodes.push_back(u);

      }

      // Initialize the next arcs

      for (int u = 0; u != _res_node_num; ++u) {

        _next_out[u] = _first_out[u];

      }

    }

        }

      }

      }

    }

    // Global potential update heuristic

    void globalUpdate() {

      const int bucket_end = _root + 1;

      // Initialize buckets

      for (int r = 0; r != _max_rank; ++r) {

        _buckets[r] = bucket_end;

      }

      Value total_excess = 0;

      int b0 = bucket_end;

      for (int i = 0; i != _res_node_num; ++i) {

        if (_excess[i] < 0) {

          _rank[i] = 0;

          _bucket_next[i] = b0;

          _bucket_prev[b0] = i;

          b0 = i;

        } else {

          total_excess += _excess[i];

          _rank[i] = _max_rank;

        }

      }

      if (total_excess == 0) return;

      _buckets[0] = b0;

      // Search the buckets

      int r = 0;

      for ( ; r != _max_rank; ++r) {

        while (_buckets[r] != bucket_end) {

          // Remove the first node from the current bucket

          int u = _buckets[r];

          _buckets[r] = _bucket_next[u];

          // Search the incomming arcs of u

          LargeCost pi_u = _pi[u];

          int last_out = _first_out[u+1];

          for (int a = _first_out[u]; a != last_out; ++a) {

            int ra = _reverse[a];

            if (_res_cap[ra] > 0) {

              int v = _source[ra];

              int old_rank_v = _rank[v];

              if (r < old_rank_v) {

                // Compute the new rank of v

                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;

                int new_rank_v = old_rank_v;

                if (nrc < LargeCost(_max_rank)) {

                  new_rank_v = r + 1 + static_cast<int>(nrc);

                }

                // Change the rank of v

                if (new_rank_v < old_rank_v) {

                  _rank[v] = new_rank_v;

                  _next_out[v] = _first_out[v];

                  // Remove v from its old bucket

                  if (old_rank_v < _max_rank) {

                    if (_buckets[old_rank_v] == v) {

                      _buckets[old_rank_v] = _bucket_next[v];

                    } else {

                      int pv = _bucket_prev[v], nv = _bucket_next[v];

                      _bucket_next[pv] = nv;

                      _bucket_prev[nv] = pv;

                    }

                  }

                  // Insert v into its new bucket

                  int nv = _buckets[new_rank_v];

                  _bucket_next[v] = nv;

                  _bucket_prev[nv] = v;

                  _buckets[new_rank_v] = v;

                }

              }

            }

          }

          // Finish search if there are no more active nodes

          if (_excess[u] > 0) {

            total_excess -= _excess[u];

            if (total_excess <= 0) break;

          }

        }

        if (total_excess <= 0) break;

      }

      // Relabel nodes

      for (int u = 0; u != _res_node_num; ++u) {

        int k = std::min(_rank[u], r);

        if (k > 0) {

          _pi[u] -= _epsilon * k;

          _next_out[u] = _first_out[u];

        }

      }

    }

    /// Execute the algorithm performing augment and relabel operations

    void startAugment(int max_length) {

      // Paramters for heuristics

      const double GLOBAL_UPDATE_FACTOR = 1.0;

      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *

        (_res_node_num + _sup_node_num * _sup_node_num));

      int next_global_update_limit = global_update_skip;

      // Perform cost scaling phases

      IntVector path;

      BoolVector path_arc(_res_arc_num, false);

      int relabel_cnt = 0;

      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?

                                        1 : _epsilon / _alpha )

      {

        }

        // Initialize current phase

        initPhase();

        // Perform partial augment and relabel operations

        while (true) {

          // Select an active node (FIFO selection)

          while (_active_nodes.size() > 0 &&

                 _excess[_active_nodes.front()] <= 0) {

            _active_nodes.pop_front();

          }

          if (_active_nodes.size() == 0) break;

          int start = _active_nodes.front();

          // Find an augmenting path from the start node

          int tip = start;

          while (int(path.size()) < max_length && _excess[tip] >= 0) {

            int u;

            LargeCost rc, min_red_cost = std::numeric_limits<LargeCost>::max();

            LargeCost pi_tip = _pi[tip];

            int last_out = _first_out[tip+1];

            for (int a = _next_out[tip]; a != last_out; ++a) {

              if (_res_cap[a] > 0) {

                u = _target[a];

                rc = _cost[a] + pi_tip - _pi[u];

                if (rc < 0) {

                  path.push_back(a);

                  _next_out[tip] = a;

                  if (path_arc[a]) {

                    goto augment;   // a cycle is found, stop path search

                  }

                  tip = u;

                  path_arc[a] = true;

                  goto next_step;

                }

                else if (rc < min_red_cost) {

                  min_red_cost = rc;

                }

              }

            }

            // Relabel tip node

            if (tip != start) {

              int ra = _reverse[path.back()];

              min_red_cost =

                std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]);

            }

            last_out = _next_out[tip];

            for (int a = _first_out[tip]; a != last_out; ++a) {

              if (_res_cap[a] > 0) {

                rc = _cost[a] + pi_tip - _pi[_target[a]];

                if (rc < min_red_cost) {

                  min_red_cost = rc;

                }

              }

            }

            _pi[tip] -= min_red_cost + _epsilon;

            _next_out[tip] = _first_out[tip];

            ++relabel_cnt;

            // Step back

            if (tip != start) {

              int pa = path.back();

              path_arc[pa] = false;

              tip = _source[pa];

              path.pop_back();

            }

          next_step: ;

          }

          // Augment along the found path (as much flow as possible)

        augment:

          Value delta;

          int pa, u, v = start;

          for (int i = 0; i != int(path.size()); ++i) {

            pa = path[i];

            u = v;

            v = _target[pa];

            path_arc[pa] = false;

            delta = std::min(_res_cap[pa], _excess[u]);

            _res_cap[pa] -= delta;

            _res_cap[_reverse[pa]] += delta;

            _excess[u] -= delta;

            _excess[v] += delta;

            if (_excess[v] > 0 && _excess[v] <= delta) {

              _active_nodes.push_back(v);

            }

          }

          path.clear();

          // Global update heuristic

          if (relabel_cnt >= next_global_update_limit) {

            globalUpdate();

            next_global_update_limit += global_update_skip;

          }

        }

      }

    }

    /// Execute the algorithm performing push and relabel operations

    void startPush() {

      // Paramters for heuristics

      const double GLOBAL_UPDATE_FACTOR = 2.0;

      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *

        (_res_node_num + _sup_node_num * _sup_node_num));

      int next_global_update_limit = global_update_skip;

      // Perform cost scaling phases

      BoolVector hyper(_res_node_num, false);

      LargeCostVector hyper_cost(_res_node_num);

      int relabel_cnt = 0;

      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?

                                        1 : _epsilon / _alpha )

      {

        }

        // Initialize current phase

        initPhase();

        // Perform push and relabel operations

        while (_active_nodes.size() > 0) {

          LargeCost min_red_cost, rc, pi_n;

          Value delta;

          int n, t, a, last_out = _res_arc_num;

        next_node:

          // Select an active node (FIFO selection)

          n = _active_nodes.front();

          last_out = _first_out[n+1];

          pi_n = _pi[n];

          // Perform push operations if there are admissible arcs

          if (_excess[n] > 0) {

            for (a = _next_out[n]; a != last_out; ++a) {

              if (_res_cap[a] > 0 &&

                  _cost[a] + pi_n - _pi[_target[a]] < 0) {

                delta = std::min(_res_cap[a], _excess[n]);

                t = _target[a];

                // Push-look-ahead heuristic

                Value ahead = -_excess[t];

                int last_out_t = _first_out[t+1];

                LargeCost pi_t = _pi[t];

                for (int ta = _next_out[t]; ta != last_out_t; ++ta) {

                  if (_res_cap[ta] > 0 &&

                      _cost[ta] + pi_t - _pi[_target[ta]] < 0)

                    ahead += _res_cap[ta];

                  if (ahead >= delta) break;

                }

                if (ahead < 0) ahead = 0;

                // Push flow along the arc

                if (ahead < delta && !hyper[t]) {

                  _res_cap[a] -= ahead;

                  _res_cap[_reverse[a]] += ahead;

                  _excess[n] -= ahead;

                  _excess[t] += ahead;

                  _active_nodes.push_front(t);

                  hyper[t] = true;

                  hyper_cost[t] = _cost[a] + pi_n - pi_t;

                  _next_out[n] = a;

                  goto next_node;

                } else {

                  _res_cap[a] -= delta;

                  _res_cap[_reverse[a]] += delta;

                  _excess[n] -= delta;

                  _excess[t] += delta;

                  if (_excess[t] > 0 && _excess[t] <= delta)

                    _active_nodes.push_back(t);

                }

                if (_excess[n] == 0) {

                  _next_out[n] = a;

                  goto remove_nodes;

                }

              }

            }

            _next_out[n] = a;

          }

          // Relabel the node if it is still active (or hyper)

          if (_excess[n] > 0 || hyper[n]) {

             min_red_cost = hyper[n] ? -hyper_cost[n] :

               std::numeric_limits<LargeCost>::max();

            for (int a = _first_out[n]; a != last_out; ++a) {

              if (_res_cap[a] > 0) {

                rc = _cost[a] + pi_n - _pi[_target[a]];

                if (rc < min_red_cost) {

                  min_red_cost = rc;

                }

              }

            }

            _pi[n] -= min_red_cost + _epsilon;

            _next_out[n] = _first_out[n];

            hyper[n] = false;

            ++relabel_cnt;

          }

          // Remove nodes that are not active nor hyper

        remove_nodes:

          while ( _active_nodes.size() > 0 &&

                  _excess[_active_nodes.front()] <= 0 &&

                  !hyper[_active_nodes.front()] ) {

            _active_nodes.pop_front();

          }

          // Global update heuristic

          if (relabel_cnt >= next_global_update_limit) {

            globalUpdate();

            for (int u = 0; u != _res_node_num; ++u)

              hyper[u] = false;

            next_global_update_limit += global_update_skip;

          }

        }

      }

    }

  }; //class CostScaling

  ///@}

} //namespace lemon

#endif //LEMON_COST_SCALING_H