RhodeCode

    IntVector _deficit_nodes;

    Value _delta;

    IntVector _pred;

  public:

    /// \ref reset() is called, thus only the modified parameters

    /// have to be set again. See \ref reset() for examples.

    /// However the underlying digraph must not be modified after this

    ///

    ///

    /// \return \c INFEASIBLE if no feasible flow exists,

    /// \n \c OPTIMAL if the problem has optimal solution

    /// these cases.

    ///

    /// \see ProblemType

      if (pt != OPTIMAL) return pt;

      return start();

    }

    /// It is useful for multiple run() calls. If this function is not

    /// used, all the parameters given before are kept for the next

    /// \ref run() call.

    /// class have been constructed, since it copies and extends the graph.

    ///

    /// For example,

  private:

    // Initialize the algorithm

      if (_node_num == 0) return INFEASIBLE;

      // Check the sum of supply values

      }

      // Initialize delta value

        // With scaling

        Value max_sup = 0, max_dem = 0;

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

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

        }

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

      } else {

        // Without scaling

        _delta = 1;

    ProblemType startWithScaling() {

      // Perform capacity scaling phases

      int s, t;

      ResidualDijkstra _dijkstra(*this);

      while (true) {

        // Saturate all arcs not satisfying the optimality condition

        }

        if (_delta == 1) break;

      }

      return OPTIMAL;

  /// be integer.

  /// \warning This algorithm does not support negative costs for such

  /// arcs that have infinite upper bound.

#ifdef DOXYGEN

  template <typename GR, typename V, typename C, typename TR>

#else

      UNBOUNDED

    };

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(GR);

    /// that have been given are kept for the next call, unless

    /// \ref reset() is called, thus only the modified parameters

    /// have to be set again. See \ref reset() for examples.

    ///

    ///

    /// \return \c INFEASIBLE if no feasible flow exists,

    /// \n \c OPTIMAL if the problem has optimal solution

    /// bounded over the feasible flows, but this algroithm cannot handle

    /// these cases.

    ///

      ProblemType pt = init();

      if (pt != OPTIMAL) return pt;

      return OPTIMAL;

    }

    ProblemType init() {

      if (_res_node_num == 0) return INFEASIBLE;

      // Check the sum of supply values

      _sum_supply = 0;

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

    }

    // Execute the algorithm and transform the results

      // Execute the algorithm

      }

      // Compute node potentials for the original costs

      }

    }

      // Paramters for heuristics

      const int BF_HEURISTIC_EPSILON_BOUND = 1000;

      const int BF_HEURISTIC_BOUND_FACTOR  = 3;

      // Perform cost scaling phases

      IntVector pred_arc(_res_node_num);

          // Find an augmenting path from the start node

          int tip = start;

          while (_excess[tip] >= 0 &&

            int u;

            LargeCost min_red_cost, rc;

            int last_out = _sum_supply < 0 ?

    }

    /// Execute the algorithm performing push and relabel operations

      // Paramters for heuristics

      const int BF_HEURISTIC_EPSILON_BOUND = 1000;

      const int BF_HEURISTIC_BOUND_FACTOR  = 3;