Context Navigation

Changeset 1053:1c978b5bcc65 in lemon-main for lemon

Timestamp:

03/18/13 17:41:19 (11 years ago)

Author:

Alpar Juttner <alpar@…>

Branch:

default

Phase:

public

Message:

Use doxygen's own bibtex support (#456)

Location:

lemon

Files:

-                      r1049
+                      r1053
   /// \ref CapacityScaling implements the capacity scaling version
   /// of the successive shortest path algorithm for finding a
   /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
   /// \ref edmondskarp72theoretical. It is an efficient dual
+  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
+  /// \cite edmondskarp72theoretical. It is an efficient dual
   /// solution method, which runs in polynomial time
   /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum

-                      r1049
+                      r1053
   /// \ref CostScaling implements a cost scaling algorithm that performs
   /// push/augment and relabel operations for finding a \ref min_cost_flow
   /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
   /// \ref goldberg97efficient, \ref bunnagel98efficient.
+  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
+  /// \cite goldberg97efficient, \cite bunnagel98efficient.
   /// It is a highly efficient primal-dual solution method, which
   /// can be viewed as the generalization of the \ref Preflow

-                      r1049
+                      r1053
   /// \ref CycleCanceling implements three different cycle-canceling
   /// algorithms for finding a \ref min_cost_flow "minimum cost flow"
   /// \ref amo93networkflows, \ref klein67primal,
   /// \ref goldberg89cyclecanceling.
+  /// \cite amo93networkflows, \cite klein67primal,
+  /// \cite goldberg89cyclecanceling.
   /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
   /// "Cancel-and-Tighten" algorithm, thus it is the default method.
 …
       /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
       /// well-known strongly polynomial method
       /// \ref goldberg89cyclecanceling. It improves along a
+      /// \cite goldberg89cyclecanceling. It improves along a
       /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
       /// Its running time complexity is O(n<sup>2</sup>e<sup>3</sup>log(n)).
 …
       /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
       /// improved version of the previous method
       /// \ref goldberg89cyclecanceling.
+      /// \cite goldberg89cyclecanceling.
       /// It is faster both in theory and in practice, its running time
       /// complexity is O(n<sup>2</sup>e<sup>2</sup>log(n)).

r918	r1053
41	41	/// \ref GrossoLocatelliPullanMc implements the iterated local search
42	42	/// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
43		/// \e clique \e problem \~~ref~~ grosso08maxclique.
	43	/// \e clique \e problem \cite grosso08maxclique.
44	44	/// It is to find the largest complete subgraph (\e clique) in an
45	45	/// undirected graph, i.e., the largest set of nodes where each

r1049	r1053
99	99	/// This class implements the Hartmann-Orlin algorithm for finding
100	100	/// a directed cycle of minimum mean cost in a digraph
101		/// \~~ref hartmann93finding, \ref~~ dasdan98minmeancycle.
	101	/// \cite hartmann93finding, \cite dasdan98minmeancycle.
102	102	/// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
103	103	/// applies an early termination scheme. It makes the algorithm

r1049	r1053
99	99	/// This class implements Howard's policy iteration algorithm for finding
100	100	/// a directed cycle of minimum mean cost in a digraph
101		/// \~~ref dasdan98minmeancycle, \ref~~ dasdan04experimental.
	101	/// \cite dasdan98minmeancycle, \cite dasdan04experimental.
102	102	/// This class provides the most efficient algorithm for the
103	103	/// minimum mean cycle problem, though the best known theoretical

r1049	r1053
99	99	/// This class implements Karp's algorithm for finding a directed
100	100	/// cycle of minimum mean cost in a digraph
101		/// \~~ref karp78characterization, \ref~~ dasdan98minmeancycle.
	101	/// \cite karp78characterization, \cite dasdan98minmeancycle.
102	102	/// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
103	103	///

-                      r1049
+                      r1053
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
   /// for finding a \ref min_cost_flow "minimum cost flow"
   /// \ref amo93networkflows, \ref dantzig63linearprog,
   /// \ref kellyoneill91netsimplex.
+  /// \cite amo93networkflows, \cite dantzig63linearprog,
+  /// \cite kellyoneill91netsimplex.
   /// This algorithm is a highly efficient specialized version of the
   /// linear programming simplex method directly for the minimum cost

-                      r966
+                      r1053
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
   /// "flow of maximum value" in a digraph \ref clrs01algorithms,
   /// \ref amo93networkflows, \ref goldberg88newapproach.
+  /// "flow of maximum value" in a digraph \cite clrs01algorithms,
+  /// \cite amo93networkflows, \cite goldberg88newapproach.
   /// The preflow algorithms are the fastest known maximum
   /// flow algorithms. The current implementation uses a mixture of the

Note: See TracChangeset for help on using the changeset viewer.