COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #463: 463-c5cd8960df74.patch

File 463-c5cd8960df74.patch, 8.7 KB (added by Peter Kovacs, 11 years ago)

  • doc/groups.dox 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1375760329 -7200
# Node ID c5cd8960df7431aceee364cceeedeafccafe3360
# Parent  218171dc022d194408f71d4dd290c5b0fb21dd44
Use m instead of e for denoting the number of arcs/edges (#463)

diff --git a/doc/groups.dox b/doc/groups.dox
    a b  
    497497most efficient one, though the best known theoretical bound on its running
    498498time is exponential.
    499499Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
    500 run in time O(ne) and use space O(n<sup>2</sup>+e).
     500run in time O(nm) and use space O(n<sup>2</sup>+m).
    501501*/
    502502
    503503/**

  • lemon/bellman_ford.h 

    diff --git a/lemon/bellman_ford.h b/lemon/bellman_ford.h
    a b  
    149149  /// \ingroup shortest_path
    150150  /// This class provides an efficient implementation of the Bellman-Ford
    151151  /// algorithm. The maximum time complexity of the algorithm is
    152   /// <tt>O(ne)</tt>.
     152  /// <tt>O(nm)</tt>.
    153153  ///
    154154  /// The Bellman-Ford algorithm solves the single-source shortest path
    155155  /// problem when the arcs can have negative lengths, but the digraph

  • lemon/capacity_scaling.h 

    diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
    a b  
    6969  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
    7070  /// \cite edmondskarp72theoretical. It is an efficient dual
    7171  /// solution method, which runs in polynomial time
    72   /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum
     72  /// \f$O(m\log U (n+m)\log n)\f$, where <i>U</i> denotes the maximum
    7373  /// of node supply and arc capacity values.
    7474  ///
    7575  /// This algorithm is typically slower than \ref CostScaling and
    … …  
    646646    /// \brief Return the total cost of the found flow.
    647647    ///
    648648    /// This function returns the total cost of the found flow.
    649     /// Its complexity is O(e).
     649    /// Its complexity is O(m).
    650650    ///
    651651    /// \note The return type of the function can be specified as a
    652652    /// template parameter. For example,

  • lemon/cost_scaling.h 

    diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
    a b  
    9797  /// can be viewed as the generalization of the \ref Preflow
    9898  /// "preflow push-relabel" algorithm for the maximum flow problem.
    9999  /// It is a polynomial algorithm, its running time complexity is
    100   /// \f$O(n^2e\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
     100  /// \f$O(n^2m\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
    101101  ///
    102102  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
    103103  /// implementations available in LEMON for solving this problem.
    … …  
    670670    /// \brief Return the total cost of the found flow.
    671671    ///
    672672    /// This function returns the total cost of the found flow.
    673     /// Its complexity is O(e).
     673    /// Its complexity is O(m).
    674674    ///
    675675    /// \note The return type of the function can be specified as a
    676676    /// template parameter. For example,

  • lemon/cycle_canceling.h 

    diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
    a b  
    5151  /// \cite goldberg89cyclecanceling.
    5252  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
    5353  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
    54   /// It runs in strongly polynomial time O(n<sup>2</sup>e<sup>2</sup>log(n)),
     54  /// It runs in strongly polynomial time O(n<sup>2</sup>m<sup>2</sup>log(n)),
    5555  /// but in practice, it is typically orders of magnitude slower than
    5656  /// the scaling algorithms and \ref NetworkSimplex.
    5757  /// (For more information, see \ref min_cost_flow_algs "the module page".)
    … …  
    133133      /// well-known strongly polynomial method
    134134      /// \cite goldberg89cyclecanceling. It improves along a
    135135      /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
    136       /// Its running time complexity is O(n<sup>2</sup>e<sup>3</sup>log(n)).
     136      /// Its running time complexity is O(n<sup>2</sup>m<sup>3</sup>log(n)).
    137137      MINIMUM_MEAN_CYCLE_CANCELING,
    138138      /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
    139139      /// improved version of the previous method
    140140      /// \cite goldberg89cyclecanceling.
    141141      /// It is faster both in theory and in practice, its running time
    142       /// complexity is O(n<sup>2</sup>e<sup>2</sup>log(n)).
     142      /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).
    143143      CANCEL_AND_TIGHTEN
    144144    };
    145145
    … …  
    576576    /// \brief Return the total cost of the found flow.
    577577    ///
    578578    /// This function returns the total cost of the found flow.
    579     /// Its complexity is O(e).
     579    /// Its complexity is O(m).
    580580    ///
    581581    /// \note The return type of the function can be specified as a
    582582    /// template parameter. For example,

  • lemon/gomory_hu.h 

    diff --git a/lemon/gomory_hu.h b/lemon/gomory_hu.h
    a b  
    4646  /// of nodes can easily be obtained.
    4747  ///
    4848  /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
    49   /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
     49  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall
    5050  /// time complexity. It calculates a rooted Gomory-Hu tree.
    5151  /// The structure of the tree and the edge weights can be
    5252  /// obtained using \c predNode(), \c predValue() and \c rootDist().

  • lemon/hartmann_orlin_mmc.h 

    diff --git a/lemon/hartmann_orlin_mmc.h b/lemon/hartmann_orlin_mmc.h
    a b  
    102102  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
    103103  /// applies an early termination scheme. It makes the algorithm
    104104  /// significantly faster for some problem instances, but slower for others.
    105   /// The algorithm runs in time O(ne) and uses space O(n<sup>2</sup>+e).
     105  /// The algorithm runs in time O(nm) and uses space O(n<sup>2</sup>+m).
    106106  ///
    107107  /// \tparam GR The type of the digraph the algorithm runs on.
    108108  /// \tparam CM The type of the cost map. The default

  • lemon/karp_mmc.h 

    diff --git a/lemon/karp_mmc.h b/lemon/karp_mmc.h
    a b  
    9999  /// This class implements Karp's algorithm for finding a directed
    100100  /// cycle of minimum mean cost in a digraph
    101101  /// \cite karp78characterization, \cite dasdan98minmeancycle.
    102   /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
     102  /// It runs in time O(nm) and uses space O(n<sup>2</sup>+m).
    103103  ///
    104104  /// \tparam GR The type of the digraph the algorithm runs on.
    105105  /// \tparam CM The type of the cost map. The default

  • lemon/min_cost_arborescence.h 

    diff --git a/lemon/min_cost_arborescence.h b/lemon/min_cost_arborescence.h
    a b  
    101101  /// more sources should be given to the algorithm and it will calculate
    102102  /// the minimum cost subgraph that is the union of arborescences with the
    103103  /// given sources and spans all the nodes which are reachable from the
    104   /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
     104  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).
    105105  ///
    106106  /// The algorithm also provides an optimal dual solution, therefore
    107107  /// the optimality of the solution can be checked.

  • lemon/network_simplex.h 

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    973973    /// \brief Return the total cost of the found flow.
    974974    ///
    975975    /// This function returns the total cost of the found flow.
    976     /// Its complexity is O(e).
     976    /// Its complexity is O(m).
    977977    ///
    978978    /// \note The return type of the function can be specified as a
    979979    /// template parameter. For example,

  • lemon/preflow.h 

    diff --git a/lemon/preflow.h b/lemon/preflow.h
    a b  
    107107  /// The preflow algorithms are the fastest known maximum
    108108  /// flow algorithms. The current implementation uses a mixture of the
    109109  /// \e "highest label" and the \e "bound decrease" heuristics.
    110   /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
     110  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$.
    111111  ///
    112112  /// The algorithm consists of two phases. After the first phase
    113113  /// the maximum flow value and the minimum cut is obtained. The

  • lemon/suurballe.h 

    diff --git a/lemon/suurballe.h b/lemon/suurballe.h
    a b  
    682682    ///
    683683    /// This function returns the total length of the found paths, i.e.
    684684    /// the total cost of the found flow.
    685     /// The complexity of the function is O(e).
     685    /// The complexity of the function is O(m).
    686686    ///
    687687    /// \pre \ref run() or \ref findFlow() must be called before using
    688688    /// this function.