RhodeCode

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(GR);

    typedef std::vector<int> IntVector;

    typedef std::vector<Value> ValueVector;

    typedef std::vector<Cost> CostVector;

  private:

    // Data related to the underlying digraph

    // potentials according to the found distance labels.

    class ResidualDijkstra

    {

    private:

      int _node_num;

      const IntVector &_first_out;

      const IntVector &_target;

      const CostVector &_cost;

      const ValueVector &_res_cap;

      const ValueVector &_excess;

      CostVector &_pi;

      IntVector _proc_nodes;

      CostVector _dist;

    public:

      ResidualDijkstra(CapacityScaling& cs) :

      {}

      int run(int s, Value delta = 1) {

        RangeMap<int> heap_cross_ref(_node_num, Heap::PRE_HEAP);

        Heap heap(heap_cross_ref);

        heap.push(s, 0);

          Cost d = heap.prio() + _pi[u], dn;

          _dist[u] = heap.prio();

          _proc_nodes.push_back(u);

          heap.pop();

          // Traverse outgoing residual arcs

            if (_res_cap[a] < delta) continue;

            v = _target[a];

            switch (heap.state(v)) {

              case Heap::PRE_HEAP:

                heap.push(v, d + _cost[a] - _pi[v]);

                _pred[v] = a;

      _sum_supply = 0;

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

        _sum_supply += _supply[i];

      }

      if (_sum_supply > 0) return INFEASIBLE;

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

        _pi[i] = 0;

        _excess[i] = _supply[i];

      }

      // Remove non-zero lower bounds

      if (_have_lower) {

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

            if (_forward[j]) {

              Value c = _lower[j];

              if (c >= 0) {

              } else {

              }

              _excess[i] -= c;

              _excess[_target[j]] += c;

            } else {

              _res_cap[j] = 0;

            }

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

          _res_cap[j] = _forward[j] ? _upper[j] : 0;

        }

      }

      // Handle negative costs

          }

        }

      }

      // Handle GEQ supply type

      if (_sum_supply < 0) {

        _pi[_root] = 0;

        _excess[_root] = -_sum_supply;

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

          _cost[a] = 0;

        }

      } else {

        _pi[_root] = 0;

        _excess[_root] = 0;

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

          _res_cap[a] = 1;

          _cost[a] = 0;

        }

      }

      // Initialize delta value

      if (_factor > 1) {

        // With scaling

        Value max_sup = 0, max_dem = 0;

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

        }

        Value max_cap = 0;

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

          if (_res_cap[j] > max_cap) max_cap = _res_cap[j];

        }

        max_sup = std::min(std::min(max_sup, max_dem), max_cap);

        pt = startWithScaling();

      else

        pt = startWithoutScaling();

      // Handle non-zero lower bounds

      if (_have_lower) {

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

        }

      }

      // Shift potentials if necessary

      Cost pr = _pi[_root];

    ProblemType startWithScaling() {

      // Perform capacity scaling phases

      int s, t;

      ResidualDijkstra _dijkstra(*this);

      while (true) {

        // Saturate all arcs not satisfying the optimality condition

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

            int v = _target[a];

            Cost c = _cost[a] + _pi[u] - _pi[v];

            Value rc = _res_cap[a];

            if (c < 0 && rc >= _delta) {

              _excess[u] -= rc;

              _excess[v] += rc;

        }

        // Find excess nodes and deficit nodes

        _excess_nodes.clear();

        _deficit_nodes.clear();

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

        }

        int next_node = 0, next_def_node = 0;

        // Find augmenting shortest paths

        while (next_node < int(_excess_nodes.size())) {

          // Check deficit nodes

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(GR);

    typedef std::vector<int> IntVector;

    typedef std::vector<Value> ValueVector;

    typedef std::vector<Cost> CostVector;

    // State constants for arcs

    enum ArcStateEnum {

      STATE_UPPER = -1,

    IntVector _pred;

    IntVector _thread;

    IntVector _rev_thread;

    IntVector _succ_num;

    IntVector _last_succ;

    IntVector _dirty_revs;

    int _root;

    // Temporary data used in the current pivot iteration

    int in_arc, join, u_in, v_in, u_out, v_out;

    int first, second, right, last;

    int stem, par_stem, new_stem;

    Value delta;

  public:

    /// \brief Constant for infinite upper bounds (capacities).

    ///

    /// Constant for infinite upper bounds (capacities).

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const CostVector &_pi;

      int &_in_arc;

      int _search_arc_num;

      // Pivot rule data

      int _next_arc;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const CostVector &_pi;

      int &_in_arc;

      int _search_arc_num;

    public:

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const CostVector &_pi;

      int &_in_arc;

      int _search_arc_num;

      // Pivot rule data

      int _block_size;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const CostVector &_pi;

      int &_in_arc;

      int _search_arc_num;

      // Pivot rule data

      IntVector _candidates;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      const CostVector &_pi;

      int &_in_arc;

      int _search_arc_num;

      // Pivot rule data

      int _block_size, _head_length, _curr_length;

    /// \param arc_mixing Indicate if the arcs have to be stored in a

    /// mixed order in the internal data structure. 

    /// In special cases, it could lead to better overall performance,

    /// but it is usually slower. Therefore it is disabled by default.

    NetworkSimplex(const GR& graph, bool arc_mixing = false) :

      _graph(graph), _node_id(graph), _arc_id(graph),

      INF(std::numeric_limits<Value>::has_infinity ?

    {

      // Check the value types

      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,

        "The flow type of NetworkSimplex must be signed");

      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,

        "The cost type of NetworkSimplex must be signed");

      // Remove non-zero lower bounds

      if (_have_lower) {

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

          Value c = _lower[i];

          if (c >= 0) {

          } else {

          }

          _supply[_source[i]] -= c;

          _supply[_target[i]] += c;

        }

      } else {

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

      int e;

      // Search the cycle along the path form the first node to the root

      for (int u = first; u != join; u = _parent[u]) {

        e = _pred[u];

        d = _forward[u] ?

        if (d < delta) {

          delta = d;

          u_out = u;

          result = 1;

        }

      }

      // Search the cycle along the path form the second node to the root

      for (int u = second; u != join; u = _parent[u]) {

        e = _pred[u];

        d = _forward[u] ? 

        if (d <= delta) {

          delta = d;

          u_out = u;

          result = 2;

        }

      }

      PivotRuleImpl pivot(*this);

      // Execute the Network Simplex algorithm

      while (pivot.findEnteringArc()) {

        findJoinNode();

        bool change = findLeavingArc();

        changeFlow(change);

        if (change) {

          updateTreeStructure();

          updatePotential();

        }

      }