Sync from upstream.

2026-01-19 04:12:11 +00:00 · 2025-04-04 21:39:36 -05:00
parent dabe257fda cbae97953a
commit 258f47a3b1
155 changed files with 3050 additions and 2035 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -5,6 +5,7 @@ AlignEscapedNewlinesLeft: true
 AlwaysBreakAfterDefinitionReturnType: None
 BreakBeforeBraces: Allman
 BreakConstructorInitializersBeforeComma: false
+BreakTemplateDeclarations: Yes
 ColumnLimit: 80
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 0
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -176,3 +176,227 @@ jobs:
      - name: Test
        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.3
        working-directory: ../boost-root/libs/graph/test
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-13
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-13
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,7 +22,6 @@ target_link_libraries(boost_graph
    Boost::array
    Boost::assert
    Boost::bimap
-    Boost::bind
    Boost::concept_check
    Boost::config
    Boost::container_hash
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-Boost Graph Library  [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https://drone.cpp.al/boostorg/graph)[![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions)
+# Boost Graph Library

 ===================

@@ -6,7 +6,7 @@ A generic interface for traversing graphs, using C++ templates.

 The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/graph/doc/index.html).

-## Support, bugs and feature requests ##
+## Support, bugs and feature requests

 Bugs and feature requests can be reported through the [Github issue page](https://github.com/boostorg/graph/issues).

@@ -22,13 +22,15 @@ You can submit your changes through a [pull request](https://github.com/boostorg
 There is no mailing-list specific to Boost Graph, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [graph].


-## Development ##
+### Build Status

 |                  |  Master  |   Develop   |
 |------------------|----------|-------------|
-| Github Actions | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
+| Github Actions | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
 |Drone | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/graph) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https:/drone.cpp.al/boostorg/graph) |

+## Development
+
 Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)):

    git clone https://github.com/boostorg/boost
@@ -45,7 +47,7 @@ Boost Graph Library is mostly made of headers but also contains some compiled co

 **Note:** The Boost Graph Library cannot currently be built outside of Boost itself.

-### Running tests ###
+### Running tests
 First, make sure you are in `libs/graph/test`.
 You can either run all the 300+ tests listed in `Jamfile.v2` or run a single test:

--- a/doc/bibliography.html
+++ b/doc/bibliography.html
@@ -453,6 +453,11 @@ Journal of the ACM (JACM), 23(2): 221-234, 1976.
 <em>Data Structures for Weighted Matching and Nearest Common Ancestors with Linking</em><br>
 Proceedings of the First Annual ACM-SIAM Symposium on Discrete Algorithms, pp. 434-443, 1990.

+<p></p><dt><a name="galil86">77</a>
+<dd>Zvi Galil<br>
+<em><a href="https://dl.acm.org/doi/pdf/10.1145/6462.6502">Efficient Algorithms for Finding Maximum Matching in Graphs</a></em><br>
+ACM Computing Surveys (CSUR), 18(1), 23-38, 1986.
+
 </dl>

 <br>
--- a/doc/grid_graph.html
+++ b/doc/grid_graph.html
@@ -69,7 +69,7 @@
    <p>
      Defined in
      <a href="../../../boost/graph/grid_graph.hpp"><tt>boost/graph/grid_graph.hpp</tt></a>
-      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
+      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_properties.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
    </p>

    <h4>Template Parameters</h4>
--- a/doc/maximum_weighted_matching.html
+++ b/doc/maximum_weighted_matching.html
@@ -1,5 +1,6 @@
 <html><head><!--
     Copyright 2018 Yi Ji
+     Copyright 2025 Joris van Rantwijk

     Use, modification and distribution is subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +21,9 @@ void maximum_weighted_matching(const Graph&amp; g, MateMap mate);
 template &lt;typename Graph, typename MateMap, typename VertexIndexMap&gt;
 void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm);

+template &lt;typename Graph, typename MateMap, typename VertexIndexMap, typename EdgeWeightMap&gt;
+void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm, EdgeWeightMap weights);
+
 template &lt;typename Graph, typename MateMap&gt;
 void brute_force_maximum_weighted_matching(const Graph&amp; g, MateMap mate);

@@ -56,77 +60,126 @@ maximum weighted matching in any undirected graph. The matching is returned in a
 <a href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>
 that maps vertices to vertices. In the mapping returned, each vertex is either mapped
 to the vertex it's matched to, or to <tt>graph_traits&lt;Graph&gt;::null_vertex()</tt> if it
-doesn't participate in the matching. If no <tt>VertexIndexMap</tt> is provided, both functions
-assume that the <tt>VertexIndexMap</tt> is provided as an internal graph property accessible
-by calling <tt>get(vertex_index, g)</tt>.
+doesn't participate in the matching.
+</p>
+
+<h3>Algorithm Description</h3>

 <p>
-The maximum weighted matching problem was solved by Edmonds in [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
-The implementation of <tt>maximum_weighted_matching</tt> followed Chapter 6, Section 10 of [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and
-was written in a consistent style with <tt>edmonds_maximum_cardinality_matching</tt> because of their algorithmic similarity.
-In addition, a brute-force verifier <tt>brute_force_maximum_weighted_matching</tt> simply searches all possible matchings in any graph and selects one with the maximum weight sum.
-
-</p><h3>Algorithm Description</h3>
-
-Primal-dual method in linear programming is introduced to solve weighted matching problems. Edmonds proved that for any graph,
-the maximum number of edges in a matching is equal to the minimum capacity of an odd-set cover; this further enable us to prove a max-min duality theorem for weighted matching.
-Let <i>H<sub>k-1</sub></i> denote any graph obtained from G by contracting odd sets of three or more nodes and deleting single nodes,
-where the capacity of the family of odd sets (not necessarily a cover of G) is <i>k-1</i>. Let <i>X<sub>k</sub></i> denote any matching containing <i>k</i> edges.
-Each edge <i>(i, j)</i> has a weight <i>w<sub>ij</sub></i>. We have:
-<math>
-max<i><sub>X<sub>k</sub></sub></i> min {<i>w<sub>ij</sub>|(i, j) ϵ X<sub>k</sub></i>} = min<i><sub>H<sub>k-1</sub></sub></i> max {<i>w<sub>ij</sub>|(i, j) ϵ H<sub>k-1</sub></i>}.
-</math>
-This matching duality theorem gives an indication of how the matching problem should be formulated as a linear programming problem. That is,
-the theorem suggests a set of linear inequalities which are satisfied by any matching, and it is anticipated that these inequalities describe a convex polyhedron
-with integer vertices corresponding to feasible matchings.
+The maximum weighted matching problem was solved by Edmonds in
+[<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
+Subsequently, Gabow [<a href="bibliography.html#gabow76">75</a>] and
+Lawler [<a href="bibliography.html#lawler76:_comb_opt">20</a>] developed methods
+to reduce the run time from <i>O(V<sup>4</sup>)</i> to <i>O(V<sup>3</sup>)</i>.
+The implementation of <tt>maximum_weighted_matching</tt> follows a description
+of the <i>O(V<sup>3</sup>)</i> algorithm by Galil [<a href="bibliography.html#galil86">77</a>].
+</p>

 <p>
-For <tt>maximum_weighted_matching</tt>, the management of blossoms is much more involved than in the case of <tt>max_cardinality_matching</tt>.
-It is not sufficient to record only the outermost blossoms. When an outermost blossom is expanded,
-it is necessary to know which blossom are nested immediately with it, so that these blossoms can be restored to the status of the outermost blossoms.
-When augmentation occurs, blossoms with strictly positive dual variables must be maintained for use in the next application of the labeling procedure.
+Starting from an empty matching, the algorithm repeatedly augments the matching until no further improvement is possible.
+Alternating trees and blossoms are used to find an augmenting path, in a way that is similar to maximum cardinality matching.
+A linear programming technique is used to ensure that the selected augmenting path has maximum weight.
+This involves assigning dual variables to vertices and blossoms, and computing slack values for edges.
+</p>

 <p>
-The outline of the algorithm is as follow:
+The outline of the algorithm is as follows:
+</p>

 <ol start="0">
-<li>Start with an empty matching and initialize dual variables as a half of maximum edge weight.</li>
-<li>(Labeling) Root an alternate tree at each exposed node, and proceed to construct alternate trees by labeling, using only edges with zero slack value.
+<li>Start with an empty matching and initialize dual variables to half of the maximum edge weight.</li>
+<li>(Labeling) Root a tree at each non-matched vertex, and proceed to construct alternating trees by labeling, using only edges with zero slack value.
 If an augmenting path is found, go to step 2. If a blossom is formed, go to step 3. Otherwise, go to step 4. </li>
-<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching,
-correct labels on nodes in the augmenting path, expand blossoms with zero dual variables and remove labels from all base nodes. Go to step 1.</li>
-<li>(Blossoming) Determine the membership and base node of the new blossom and supply missing labels for all non-base nodes in the blossom.
+<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching.
+Deconstruct and unlabel the alternating trees traversed by the augmenting path.
+Go to step 1.</li>
+<li>(Blossoming) Identify the blossoms in the alternating cycle and shrink these into a newly formed blossom.
 Return to step 1.</li>
-<li>(Revision of Dual Solution) Adjust the dual variables based on the primal-dual method. Go to step 1 or halt, accordingly.</li>
+<li>(Updating dual variables) Adjust the dual variables based on the primal-dual method.
+If this enables further growth of the alternating trees, return to step 1.
+Otherwise, halt the algorithm; the matching has maximum weight.</li>
 </ol>

-Note that in <tt>maximum_weighted_matching</tt>, all edge weights are multiplied by 4, so that all dual variables always remain as integers if all edge weights are integers.
-Unlike <tt>max_cardinality_matching</tt>, the initial matching and augmenting path finder are not parameterized,
-because the algorithm maintains blossoms, dual variables and node labels across all augmentations.
+<p>
+The implementation deviates from the description in [<a href="bibliography.html#galil86">77</a>] on a few points:
+</p>

-The algorithm's time complexity is reduced from <i>O(V<sup>4</sup>)</i> (naive implementation of [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>])
-to <i>O(V<sup>3</sup>)</i>, by a delicate labeling procedure [<a href="bibliography.html#gabow76">75</a>] to avoid re-scanning labels after revision of the dual solution.
-Special variables <i>pi, tau, gamma</i> and two arrays <i>critical_edge, tau_idx</i> are introduced for this purpose.
-Please refer to [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and code comments for more implementation details.
+<ul>
+<li>
+After augmenting the matching, [<a href="bibliography.html#galil86">77</a>] expands all blossoms with zero dual.
+This is correct but potentially unnecessary; some of the expanded blossoms will be recreated during the next stage.
+The implementation holds off on the expansion of such blossoms.
+In any scenario where a blossom <i>must</i> be expanded to make progress, label T will be assigned to it.
+At that point, the blossom will be expanded through a zero-delta dual step.
+The additional cost is <i>O(V)</i> per expanded blossom, and the total number of blossom expansions is <i>O(V<sup>2</sup>)</i>,
+therefore this does not change the overall time complexity of the algorithm.
+</li>
+<li>
+The algorithm records a minimum-slack edge <i>e<sub>k,l</sub></i> for every pair of blossoms <i>B<sub>k</sub>, B<sub>l</sub></i>.
+Storing these edges in a 2-dimensional array would increase the space complexity to <i>O(V<sup>2</sup>)</i>;
+an unfortunate cost for large sparse graphs.
+The implementation of <tt>maximum_weighted_matching</tt> avoids this by maintaining, for each blossom <i>B<sub>k</sub></i>,
+a list <tt>B<sub>k</sub>.best_edge_set</tt> that contains the non-empty elements of <i>e<sub>k,l</sub></i>,
+plus edges between <i>B<sub>k</sub></i> and <i>B<sub>l</sub></i> discovered after shrinking <i>B<sub>k</sub></i>.
+The combined length of these lists is <i>O(E)</i>, since any edge is contained in at most two lists.
+The algorithm only ever examines <i>e<sub>k,l</sub></i> during the process of merging <i>B<sub>k</sub></i> into a larger blossom.
+In that case, it sequentially examines <i>e<sub>k,l</sub></i> for all <i>l</i>, taking time <i>O(V)</i>.
+The implementation handles this by examining every element of <tt>B<sub>k</sub>.best_edge_set</tt>,
+taking time <i>O(V)</i> plus a constant time per newly discovered edge.
+This does not change the overall time complexity of the algorithm.
+</li>
+<li>
+After augmenting, [<a href="bibliography.html#galil86">77</a>] removes all labels and alternating trees.
+This keeps the algorithm simple, but it causes many trees and labels to be rediscovered at the beginning of the new stage.
+To avoid such redundent work, <tt>maximum_weighted_matching</tt> removes labels only from the two alternating trees that are touched by the augmenting path.
+All other labels and trees are reused in the next stage.
+Erasing labels from a subset of the graph, requires updating the data structures that track minimum-slack edges.
+This involves examining all edges that either touch a blossom which loses its label or touch a vertex which depended on a lost label.
+These steps take <i>O(V + E)</i> per stage, adding up to <i>O(V<sup>3</sup>)</i> in total.
+Although this strategy does not improve the worst-case time complexity of the algorithm, it achieves a significant speedup in benchmarks on random graphs.
+</li>
+</ul>
+
+<p>
+If edge weights are integers, the algorithm uses only integer computations.
+This is achieved by internally multiplying edge weights by 2, which ensures that all dual variables are also integers.
+</p>
+
+<p>
+A brute-force implementation <tt>brute_force_maximum_weighted_matching</tt> is also provided.
+This algorithm simply searches all possible matchings and selects one with the maximum weight sum.
+</p>

 </p><h3>Where Defined</h3>

 <p>
 <a href="../../../boost/graph/maximum_weighted_matching.hpp"><tt>boost/graph/maximum_weighted_matching.hpp</tt></a>
+</p>

-</p><h3>Parameters</h3>
+<h3>Parameters</h3>

 IN: <tt>const Graph&amp; g</tt>
 <blockquote>
 An undirected graph. The graph type must be a model of
 <a href="VertexAndEdgeListGraph.html">Vertex and Edge List Graph</a> and
 <a href="IncidenceGraph.html">Incidence Graph</a>.
-The edge property of the graph <tt>property_map&lt;Graph, edge_weight_t&gt;</tt> must exist and have numeric value type.<br>
+The graph may not contain parallel edges.
 </blockquote>

 IN: <tt>VertexIndexMap vm</tt>
 <blockquote>
-Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping vertices to integer indices.
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>,
+mapping vertices to integer indices in the range <tt>[0, num_vertices(g))</tt>.
+If this parameter is not explicitly specified, it is obtained from the internal vertex property of the graph
+by calling <tt>get(vertex_index, g)</tt>.
+</blockquote>
+
+IN: <tt>EdgeWeightMap weights</tt>
+<blockquote>
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping edges to weights.
+Edge weights must be integers or floating point values.
+If this parameter is not explicitly specified, it is obtained from the internal edge property of the graph
+by calling <tt>get(edge_weight, g)</tt>.
 </blockquote>

 OUT: <tt>MateMap mate</tt>
@@ -140,24 +193,29 @@ vertices to vertices. For any vertex v in the graph, <tt>get(mate,v)</tt> will b

 <p>
 Let <i>m</i> and <i>n</i> be the number of edges and vertices in the input graph, respectively. Assuming the
-<tt>VertexIndexMap</tt> supplied allows constant-time lookup, the time complexity for
-<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>. For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential of <i>m</i>.
+<tt>VertexIndexMap</tt> and <tt>EdgeWeightMap</tt> both provide constant-time lookup, the time complexity for
+<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>.
+For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential in <i>m</i>.
+</p>
+
+<p>
 Note that the best known time complexity for maximum weighted matching in general graph
 is <i>O(nm+n<sup>2</sup>log(n))</i> by [<a href="bibliography.html#gabow90">76</a>], but relies on an
 efficient algorithm for solving nearest ancestor problem on trees, which is not provided in Boost C++ libraries.
-</p><p>
+</p>

-</p><h3>Example</h3>
+<h3>Example</h3>

-<p> The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
+<p>The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
 contains an example.
+</p>

-<br>
-</p><hr>
+<hr>
 <table>
 <tbody><tr valign="top">
-<td nowrap="nowrap">Copyright © 2018</td><td>
-Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>)<br>
+<td nowrap="nowrap">Copyright © 2018, 2025</td><td>
+Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>),
+Joris van Rantwijk
 </td></tr></tbody></table>

 </body></html>
--- a/doc/using_adjacency_list.html
+++ b/doc/using_adjacency_list.html
@@ -133,7 +133,7 @@ out-edges for the whole graph.
 <PRE>
 vertex()
 </PRE>
-This operation is constant time for <TT>vecS</TT> and  for
+This operation is constant time for <TT>vecS</TT> and <i>O(V)</i> for
 <TT>listS</TT>.

 </ul>
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@@ -168,6 +168,7 @@ run vertex-name-property.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)
 run vf2_sub_graph_iso_example.cpp ;
 run vf2_sub_graph_iso_multi_example.cpp ;
 run visitor.cpp ;
+run weighted_matching_example.cpp ;
 run write_graphviz.cpp ;

 #
--- a/example/accum-compile-times.cpp
+++ b/example/accum-compile-times.cpp
@@ -72,12 +72,8 @@ int main(int argc, const char** argv)
    file_dep_graph2 g(input_begin, input_end, n_vertices);
 #endif

-    typedef property_map< file_dep_graph2, vertex_name_t >::type name_map_t;
-    typedef property_map< file_dep_graph2, vertex_compile_cost_t >::type
-        compile_cost_map_t;
-
-    name_map_t name_map = get(vertex_name, g);
-    compile_cost_map_t compile_cost_map = get(vertex_compile_cost, g);
+    auto name_map = get(vertex_name, g);
+    auto compile_cost_map = get(vertex_compile_cost, g);

    std::ifstream name_in(argc >= 3 ? argv[2] : "makefile-target-names.dat");
    std::ifstream compile_cost_in(
--- a/example/actor_clustering.cpp
+++ b/example/actor_clustering.cpp
@@ -52,13 +52,13 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
        // Map from the actor numbers on this line to the actor vertices
        typedef tokenizer< char_separator< char > > Tok;
        Tok tok(line, char_separator< char >(" "));
-        for (Tok::iterator id = tok.begin(); id != tok.end(); ++id)
+        for (auto const & id : tok)
        {
-            int actor_id = lexical_cast< int >(*id);
-            std::map< int, Vertex >::iterator v = actors.find(actor_id);
+            auto actor_id = lexical_cast< int >(id);
+            auto v = actors.find(actor_id);
            if (v == actors.end())
            {
-                Vertex new_vertex = add_vertex(Actor(actor_id), g);
+                auto new_vertex = add_vertex(Actor(actor_id), g);
                actors[actor_id] = new_vertex;
                actors_in_movie.push_back(new_vertex);
            }
@@ -68,11 +68,9 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
            }
        }

-        for (std::vector< Vertex >::iterator i = actors_in_movie.begin();
-             i != actors_in_movie.end(); ++i)
+        for (auto i = actors_in_movie.begin(); i != actors_in_movie.end(); ++i)
        {
-            for (std::vector< Vertex >::iterator j = i + 1;
-                 j != actors_in_movie.end(); ++j)
+            for (auto j = i + 1; j != actors_in_movie.end(); ++j)
            {
                if (!edge(*i, *j, g).second)
                    add_edge(*i, *j, g);
@@ -86,16 +84,14 @@ std::ostream& write_pajek_graph(std::ostream& out, const Graph& g,
    VertexIndexMap vertex_index, VertexNameMap vertex_name)
 {
    out << "*Vertices " << num_vertices(g) << '\n';
-    typedef typename graph_traits< Graph >::vertex_iterator vertex_iterator;
-    for (vertex_iterator v = vertices(g).first; v != vertices(g).second; ++v)
+    for (auto v = vertices(g).first; v != vertices(g).second; ++v)
    {
        out << get(vertex_index, *v) + 1 << " \"" << get(vertex_name, *v)
            << "\"\n";
    }

    out << "*Edges\n";
-    typedef typename graph_traits< Graph >::edge_iterator edge_iterator;
-    for (edge_iterator e = edges(g).first; e != edges(g).second; ++e)
+    for (auto e = edges(g).first; e != edges(g).second; ++e)
    {
        out << get(vertex_index, source(*e, g)) + 1 << ' '
            << get(vertex_index, target(*e, g)) + 1 << " 1.0\n"; // HACK!
--- a/example/adjacency_list.cpp
+++ b/example/adjacency_list.cpp
@@ -61,10 +61,8 @@ int main(int, char*[])
    const int V = 5;
    Graph g(V);

-    property_map< Graph, std::size_t VertexProperties::* >::type id
-        = get(&VertexProperties::index, g);
-    property_map< Graph, std::string EdgeProperties::* >::type name
-        = get(&EdgeProperties::name, g);
+    auto id = get(&VertexProperties::index, g);
+    auto name = get(&EdgeProperties::name, g);

    boost::graph_traits< Graph >::vertex_iterator vi, viend;
    int vnum = 0;
--- a/example/astar-cities.cpp
+++ b/example/astar-cities.cpp
@@ -86,8 +86,8 @@ public:
    distance_heuristic(LocMap l, Vertex goal) : m_location(l), m_goal(goal) {}
    CostType operator()(Vertex u)
    {
-        CostType dx = m_location[m_goal].x - m_location[u].x;
-        CostType dy = m_location[m_goal].y - m_location[u].y;
+        auto dx = m_location[m_goal].x - m_location[u].x;
+        auto dy = m_location[m_goal].y - m_location[u].y;
        return ::sqrt(dx * dx + dy * dy);
    }

@@ -174,7 +174,7 @@ int main(int argc, char** argv)

    // create graph
    mygraph_t g(N);
-    WeightMap weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    for (std::size_t j = 0; j < num_edges; ++j)
    {
        edge_descriptor e;
@@ -185,9 +185,9 @@ int main(int argc, char** argv)
    }

    // pick random start/goal
-    boost::mt19937 gen(std::time(0));
-    vertex start = random_vertex(g, gen);
-    vertex goal = random_vertex(g, gen);
+    boost::mt19937 gen(time(0));
+    auto start = random_vertex(g, gen);
+    auto goal = random_vertex(g, gen);

    cout << "Start vertex: " << name[start] << endl;
    cout << "Goal vertex: " << name[goal] << endl;
@@ -215,7 +215,7 @@ int main(int argc, char** argv)
    catch (found_goal fg)
    { // found a path to the goal
        list< vertex > shortest_path;
-        for (vertex v = goal;; v = p[v])
+        for (auto v = goal;; v = p[v])
        {
            shortest_path.push_front(v);
            if (p[v] == v)
@@ -223,7 +223,7 @@ int main(int argc, char** argv)
        }
        cout << "Shortest path from " << name[start] << " to " << name[goal]
             << ": ";
-        list< vertex >::iterator spi = shortest_path.begin();
+        auto spi = shortest_path.begin();
        cout << name[start];
        for (++spi; spi != shortest_path.end(); ++spi)
            cout << " -> " << name[*spi];
--- a/example/astar_maze.cpp
+++ b/example/astar_maze.cpp
@@ -201,8 +201,8 @@ bool maze::solve()
    dist_map distance;
    boost::associative_property_map< dist_map > dist_pmap(distance);

-    vertex_descriptor s = source();
-    vertex_descriptor g = goal();
+    auto s = source();
+    auto g = goal();
    euclidean_heuristic heuristic(g);
    astar_goal_visitor visitor(g);

@@ -218,7 +218,7 @@ bool maze::solve()
    {
        // Walk backwards from the goal through the predecessor chain adding
        // vertices to the solution path.
-        for (vertex_descriptor u = g; u != s; u = predecessor[u])
+        for (auto u = g; u != s; u = predecessor[u])
            m_solution.insert(u);
        m_solution.insert(s);
        m_solution_length = distance[g];
@@ -285,9 +285,9 @@ std::size_t random_int(std::size_t a, std::size_t b)
 // Generate a maze with a random assignment of barriers.
 void random_maze(maze& m)
 {
-    vertices_size_type n = num_vertices(m.m_grid);
-    vertex_descriptor s = m.source();
-    vertex_descriptor g = m.goal();
+    auto n = num_vertices(m.m_grid);
+    auto s = m.source();
+    auto g = m.goal();
    // One quarter of the cells in the maze should be barriers.
    int barriers = n / 4;
    while (barriers > 0)
@@ -297,7 +297,7 @@ void random_maze(maze& m)
        // Walls range up to one quarter the dimension length in this direction.
        vertices_size_type wall = random_int(1, m.length(direction) / 4);
        // Create the wall while decrementing the total barrier count.
-        vertex_descriptor u = vertex(random_int(0, n - 1), m.m_grid);
+        auto u = vertex(random_int(0, n - 1), m.m_grid);
        while (wall)
        {
            // Start and goal spaces should never be barriers.
@@ -310,7 +310,7 @@ void random_maze(maze& m)
                    barriers--;
                }
            }
-            vertex_descriptor v = m.m_grid.next(u, direction);
+            auto v = m.m_grid.next(u, direction);
            // Stop creating this wall if we reached the maze's edge.
            if (u == v)
                break;
--- a/example/bellman-example.cpp
+++ b/example/bellman-example.cpp
@@ -23,8 +23,7 @@ template < typename Graph, typename ParentMap > struct edge_writer
    void operator()(std::ostream& out, const Edge& e) const
    {
        out << "[label=\"" << get(edge_weight, m_g, e) << "\"";
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, m_g),
-                                                          v = target(e, m_g);
+        auto u = source(e, m_g), v = target(e, m_g);
        if (m_parent[v] == u)
            out << ", color=\"black\"";
        else
@@ -74,8 +73,7 @@ int main()
    Graph g(edge_array, edge_array + n_edges, N);
 #endif
    graph_traits< Graph >::edge_iterator ei, ei_end;
-    property_map< Graph, int EdgeProperties::* >::type weight_pmap
-        = get(&EdgeProperties::weight, g);
+    auto weight_pmap = get(&EdgeProperties::weight, g);
    int i = 0;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
        weight_pmap[*ei] = weight[i];
@@ -115,9 +113,8 @@ int main()
    {
        for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        {
-            graph_traits< Graph >::edge_descriptor e = *ei;
-            graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                     v = target(e, g);
+            auto e = *ei;
+            auto u = source(e, g), v = target(e, g);
            // VC++ doesn't like the 3-argument get function, so here
            // we workaround by using 2-nested get()'s.
            dot_file << name[u] << " -> " << name[v] << "[label=\""
--- a/example/bellman-ford-internet.cpp
+++ b/example/bellman-ford-internet.cpp
@@ -25,19 +25,18 @@ int main()
        H,
        n_vertices
    };
-    const int n_edges = 11;
    typedef std::pair< int, int > Edge;

    // The list of connections between routers stored in an array.
-    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E), Edge(C, E),
-        Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
+    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E),
+        Edge(C, E), Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
        Edge(G, H) };

    // Specify the graph type and declare a graph object
    typedef edge_list< Edge*, Edge, std::ptrdiff_t,
        std::random_access_iterator_tag >
        Graph;
-    Graph g(edges, edges + n_edges);
+    Graph g(std::begin(edges), std::end(edges));

    // The transmission delay values for each edge.
    float delay[] = { 5.0, 1.0, 1.3, 3.0, 10.0, 2.0, 6.3, 0.4, 1.3, 1.2, 0.5 };
--- a/example/bfs-example2.cpp
+++ b/example/bfs-example2.cpp
@@ -81,7 +81,7 @@ int main()
    Size time = 0;
    typedef property_map< graph_t, std::size_t VertexProps::* >::type
        dtime_map_t;
-    dtime_map_t dtime_map = get(&VertexProps::discover_time, g);
+    auto dtime_map = get(&VertexProps::discover_time, g);
    bfs_time_visitor< dtime_map_t > vis(dtime_map, time);
    breadth_first_search(
        g, vertex(s, g), color_map(get(&VertexProps::color, g)).visitor(vis));
--- a/example/bfs-name-printer.cpp
+++ b/example/bfs-name-printer.cpp
@@ -16,16 +16,15 @@ template < typename Graph, typename VertexNameMap, typename TransDelayMap >
 void build_router_network(
    Graph& g, VertexNameMap name_map, TransDelayMap delay_map)
 {
-    typename graph_traits< Graph >::vertex_descriptor a, b, c, d, e;
-    a = add_vertex(g);
+    auto a = add_vertex(g);
    name_map[a] = 'a';
-    b = add_vertex(g);
+    auto b = add_vertex(g);
    name_map[b] = 'b';
-    c = add_vertex(g);
+    auto c = add_vertex(g);
    name_map[c] = 'c';
-    d = add_vertex(g);
+    auto d = add_vertex(g);
    name_map[d] = 'd';
-    e = add_vertex(g);
+    auto e = add_vertex(g);
    name_map[e] = 'e';

    typename graph_traits< Graph >::edge_descriptor ed;
@@ -78,13 +77,13 @@ int main()
    typedef adjacency_list< listS, vecS, directedS, VP, EP > graph_t;
    graph_t g;

-    property_map< graph_t, char VP::* >::type name_map = get(&VP::name, g);
-    property_map< graph_t, double EP::* >::type delay_map = get(&EP::weight, g);
+    auto name_map = get(&VP::name, g);
+    auto delay_map = get(&EP::weight, g);

    build_router_network(g, name_map, delay_map);

    typedef property_map< graph_t, char VP::* >::type VertexNameMap;
-    graph_traits< graph_t >::vertex_descriptor a = *vertices(g).first;
+    auto a = *vertices(g).first;
    bfs_name_printer< VertexNameMap > vis(name_map);
    std::cout << "BFS vertex discover order: ";
    breadth_first_search(g, a, visitor(vis));
--- a/example/bfs.cpp
+++ b/example/bfs.cpp
@@ -129,7 +129,7 @@ int main(int, char*[])
    std::fill_n(d, 5, 0);

    // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
    p[s] = s;
    boost::breadth_first_search(G, s,
        boost::visitor(boost::make_bfs_visitor(
--- a/example/bfs_neighbor.cpp
+++ b/example/bfs_neighbor.cpp
@@ -123,7 +123,7 @@ int main(int, char*[])
    std::fill_n(d, 5, 0);

    // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
    p[s] = s;
    boost::neighbor_breadth_first_search(G, s,
        boost::visitor(boost::make_neighbor_bfs_visitor(
--- a/example/biconnected_components.cpp
+++ b/example/biconnected_components.cpp
@@ -45,10 +45,9 @@ int main()
    add_edge(6, 7, g);
    add_edge(7, 8, g);

-    property_map< graph_t, edge_component_t >::type component
-        = get(edge_component, g);
+    auto component = get(edge_component, g);

-    std::size_t num_comps = biconnected_components(g, component);
+    auto num_comps = biconnected_components(g, component);
    std::cerr << "Found " << num_comps << " biconnected components.\n";

    std::vector< vertex_t > art_points;
--- a/example/boost_web_graph.cpp
+++ b/example/boost_web_graph.cpp
@@ -29,9 +29,8 @@ public:
    void tree_edge(
        typename boost::graph_traits< Graph >::edge_descriptor e, Graph& g)
    {
-        typename boost::graph_traits< Graph >::vertex_descriptor u, v;
-        u = boost::source(e, g);
-        v = boost::target(e, g);
+        auto u = boost::source(e, g);
+        auto v = boost::target(e, g);
        distance[v] = distance[u] + 1;
    }

@@ -95,9 +94,8 @@ int main(int argc, const char** argv)
    NameVertexMap name2vertex;
    Graph g;

-    typedef property_map< Graph, vertex_name_t >::type NameMap;
-    NameMap node_name = get(vertex_name, g);
-    property_map< Graph, edge_name_t >::type link_name = get(edge_name, g);
+    auto node_name = get(vertex_name, g);
+    auto link_name = get(edge_name, g);

    //===========================================================================
    // Read the data file and construct the graph.
@@ -113,7 +111,7 @@ int main(int argc, const char** argv)
        bool inserted;
        Vertex u, v;

-        std::list< std::string >::iterator i = line_toks.begin();
+        auto i = line_toks.begin();

        boost::tie(pos, inserted)
            = name2vertex.insert(std::make_pair(*i, Vertex()));
@@ -210,6 +208,8 @@ int main(int argc, const char** argv)
    // the tree nodes in the order that we want to print out:
    // a directory-structure like format.
    std::vector< size_type > dfs_distances(num_vertices(g), 0);
+
+    using NameMap = property_map< Graph, vertex_name_t >::type;
    print_tree_visitor< NameMap, size_type* > tree_printer(
        node_name, &dfs_distances[0]);
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
--- a/example/boykov_kolmogorov-eg.cpp
+++ b/example/boykov_kolmogorov-eg.cpp
@@ -85,17 +85,15 @@ int main()
        Graph;

    Graph g;
-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
+    auto rev = get(edge_reverse, g);
    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);

    std::vector< default_color_type > color(num_vertices(g));
    std::vector< long > distance(num_vertices(g));
-    long flow = boykov_kolmogorov_max_flow(g, s, t);
+    auto flow = boykov_kolmogorov_max_flow(g, s, t);

    std::cout << "c  The total flow:" << std::endl;
    std::cout << "s " << flow << std::endl << std::endl;
--- a/example/bron_kerbosch_clique_number.cpp
+++ b/example/bron_kerbosch_clique_number.cpp
@@ -29,7 +29,7 @@ int main(int argc, char* argv[])
    read_graph(g, cin);

    // Use the Bron-Kerbosch algorithm to find all cliques, and
-    size_t c = bron_kerbosch_clique_number(g);
+    auto c = bron_kerbosch_clique_number(g);
    cout << "clique number: " << c << endl;

    return 0;
--- a/example/bucket_sorter.cpp
+++ b/example/bucket_sorter.cpp
@@ -47,7 +47,7 @@ int main()
            cout << " has number ";
            do
            {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                my_bucket_sorter[j].pop();
                cout << v << " ";
            } while (!my_bucket_sorter[j].empty());
@@ -75,7 +75,7 @@ int main()
            cout << " has number ";
            do
            {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                my_bucket_sorter[j].pop();
                cout << v << " ";
            } while (!my_bucket_sorter[j].empty());
@@ -93,7 +93,7 @@ int main()
        std::size_t current = rand() % N;
        if (!my_bucket_sorter[current].empty())
        {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
            my_bucket_sorter[current].pop();
            bucket[v] = rand() % N;
            my_bucket_sorter.push(v);
@@ -105,7 +105,7 @@ int main()
        std::size_t current = rand() % N;
        if (!my_bucket_sorter[current].empty())
        {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
            bucket[v] = rand() % N;
            my_bucket_sorter.update(v);
        }
--- a/example/canonical_ordering.cpp
+++ b/example/canonical_ordering.cpp
@@ -44,7 +44,7 @@ int main(int argc, char** argv)
    add_edge(1, 5, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -69,10 +69,9 @@ int main(int argc, char** argv)
        make_iterator_property_map(embedding.begin(), get(vertex_index, g)),
        std::back_inserter(ordering));

-    ordering_storage_t::iterator oi, oi_end;
-    oi_end = ordering.end();
+    auto oi_end = ordering.end();
    std::cout << "The planar canonical ordering is: ";
-    for (oi = ordering.begin(); oi != oi_end; ++oi)
+    for (auto oi = ordering.begin(); oi != oi_end; ++oi)
        std::cout << *oi << " ";
    std::cout << std::endl;

--- a/example/cc-internet.cpp
+++ b/example/cc-internet.cpp
@@ -32,8 +32,7 @@ int main()
        make_iterator_property_map(
            component.begin(), get(vertex_index, g), component[0]));

-    property_map< GraphvizGraph, vertex_attribute_t >::type vertex_attr_map
-        = get(vertex_attribute, g);
+    auto vertex_attr_map = get(vertex_attribute, g);
    std::string color[] = { "white", "gray", "black", "lightgray" };
    graph_traits< GraphvizGraph >::vertex_iterator vi, vi_end;
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
--- a/example/city_visitor.cpp
+++ b/example/city_visitor.cpp
@@ -137,7 +137,7 @@ int main(int, char*[])
    cout << endl;

    /* Get the source vertex */
-    boost::graph_traits< Graph >::vertex_descriptor s = vertex(SanJose, G);
+    auto s = vertex(SanJose, G);

    cout << "*** Breadth First ***" << endl;
    breadth_first_search(G, s,
--- a/example/clustering_coefficient.cpp
+++ b/example/clustering_coefficient.cpp
@@ -52,7 +52,7 @@ int main(int argc, char* argv[])
    // computation.
    ClusteringContainer coefs(num_vertices(g));
    ClusteringMap cm(coefs, g);
-    float cc = all_clustering_coefficients(g, cm);
+    auto cc = all_clustering_coefficients(g, cm);

    // Print the clustering coefficient of each vertex.
    graph_traits< Graph >::vertex_iterator i, end;
--- a/example/connected-components.cpp
+++ b/example/connected-components.cpp
@@ -24,7 +24,7 @@ int main()
    add_edge(2, 5, G);

    std::vector< int > c(num_vertices(G));
-    int num = connected_components(
+    auto num = connected_components(
        G, make_iterator_property_map(c.begin(), get(vertex_index, G), c[0]));

    std::cout << std::endl;
--- a/example/connected_components.cpp
+++ b/example/connected_components.cpp
@@ -49,7 +49,7 @@ int main(int, char*[])
        add_edge(2, 5, G);

        std::vector< int > component(num_vertices(G));
-        int num = connected_components(G, &component[0]);
+        auto num = connected_components(G, &component[0]);

        std::vector< int >::size_type i;
        cout << "Total number of components: " << num << endl;
--- a/example/copy-example.cpp
+++ b/example/copy-example.cpp
@@ -30,7 +30,7 @@ int main()
        N
    };
    graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
    char name = 'a';
    graph_traits< graph_t >::vertex_iterator v, v_end;
    for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
--- a/example/cuthill_mckee_ordering.cpp
+++ b/example/cuthill_mckee_ordering.cpp
@@ -57,32 +57,30 @@ int main(int, char*[])
        Pair(6, 7) }; // g-h

    Graph G(10);
-    for (int i = 0; i < 14; ++i)
-        add_edge(edges[i].first, edges[i].second, G);
+    for (auto const& edge : edges)
+        add_edge(edge.first, edge.second, G);

    graph_traits< Graph >::vertex_iterator ui, ui_end;

-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
        deg[*ui] = degree(*ui, G);

-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);

    std::cout << "original bandwidth: " << bandwidth(G) << std::endl;

    std::vector< Vertex > inv_perm(num_vertices(G));
    std::vector< size_type > perm(num_vertices(G));
    {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
        // reverse cuthill_mckee_ordering
        cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G));
        cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -94,15 +92,14 @@ int main(int, char*[])
                  << std::endl;
    }
    {
-        Vertex s = vertex(0, G);
+        auto s = vertex(0, G);
        // reverse cuthill_mckee_ordering
        cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G));
        cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])

        cout << "Reverse Cuthill-McKee ordering:" << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
--- a/example/cycle_canceling_example.cpp
+++ b/example/cycle_canceling_example.cpp
@@ -21,7 +21,7 @@ int main()
    boost::edmonds_karp_max_flow(g, s, t);
    boost::cycle_canceling(g);

-    int cost = boost::find_flow_cost(g);
+    auto cost = boost::find_flow_cost(g);
    assert(cost == 29);
    return 0;
 }
--- a/example/cycle_ratio_example.cpp
+++ b/example/cycle_ratio_example.cpp
@@ -50,12 +50,9 @@ int main(int argc, char* argv[])
    ccReal_t cc; /// critical cycle

    grap_real_t tgr;
-    property_map< grap_real_t, vertex_index_t >::type vim
-        = get(vertex_index, tgr);
-    property_map< grap_real_t, edge_weight_t >::type ew1
-        = get(edge_weight, tgr);
-    property_map< grap_real_t, edge_weight2_t >::type ew2
-        = get(edge_weight2, tgr);
+    auto vim = get(vertex_index, tgr);
+    auto ew1 = get(edge_weight, tgr);
+    auto ew2 = get(edge_weight2, tgr);

    gen_rand_graph(tgr, 1000, 30000);
    cout << "Vertices number: " << num_vertices(tgr) << endl;
@@ -72,12 +69,12 @@ int main(int argc, char* argv[])
    cout << "Minimum cycle ratio is " << min_cr << endl;
    std::pair< double, double > cr(.0, .0);
    cout << "Critical cycle:\n";
-    for (ccReal_t::iterator itr = cc.begin(); itr != cc.end(); ++itr)
+    for (auto const & edge : cc)
    {
-        cr.first += ew1[*itr];
-        cr.second += ew2[*itr];
-        std::cout << "(" << vim[source(*itr, tgr)] << ","
-                  << vim[target(*itr, tgr)] << ") ";
+        cr.first += ew1[edge];
+        cr.second += ew2[edge];
+        std::cout << "(" << vim[source(edge, tgr)] << ","
+                  << vim[target(edge, tgr)] << ") ";
    }
    cout << endl;
    assert(std::abs(cr.first / cr.second - min_cr) < epsilon * 2);
--- a/example/dag_shortest_paths.cpp
+++ b/example/dag_shortest_paths.cpp
@@ -50,8 +50,7 @@ int main()
    add_edge(u, x, 1, g);
    add_edge(v, x, -2, g);

-    property_map< graph_t, vertex_distance_t >::type d_map
-        = get(vertex_distance, g);
+    auto d_map = get(vertex_distance, g);

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // VC++ has trouble with the named-parameter mechanism, so
@@ -61,7 +60,7 @@ int main()
    default_dijkstra_visitor vis;
    std::less< int > compare;
    closed_plus< int > combine;
-    property_map< graph_t, edge_weight_t >::type w_map = get(edge_weight, g);
+    auto w_map = get(edge_weight, g);
    dag_shortest_paths(g, s, d_map, w_map, &color[0], &pred[0], vis, compare,
        combine, (std::numeric_limits< int >::max)(), 0);
 #else
--- a/example/dave.cpp
+++ b/example/dave.cpp
@@ -169,8 +169,7 @@ int main(int, char*[])
    };

    Graph G(N);
-    boost::property_map< Graph, vertex_index_t >::type vertex_id
-        = get(vertex_index, G);
+    auto vertex_id = get(vertex_index, G);

    std::vector< weight_t > distance(N, (numeric_limits< weight_t >::max)());
    typedef boost::graph_traits< Graph >::vertex_descriptor Vertex;
--- a/example/dijkstra-example-listS.cpp
+++ b/example/dijkstra-example-listS.cpp
@@ -44,13 +44,11 @@ int main(int, char*[])
    graph_traits< graph_t >::vertex_iterator i, iend;

    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);

    // Manually intialize the vertex index and name maps
-    property_map< graph_t, vertex_index_t >::type indexmap
-        = get(vertex_index, g);
-    property_map< graph_t, vertex_name_t >::type name = get(vertex_name, g);
+    auto indexmap = get(vertex_index, g);
+    auto name = get(vertex_name, g);
    int c = 0;
    for (boost::tie(i, iend) = vertices(g); i != iend; ++i, ++c)
    {
@@ -58,12 +56,10 @@ int main(int, char*[])
        name[*i] = 'A' + c;
    }

-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

-    property_map< graph_t, vertex_distance_t >::type d
-        = get(vertex_distance, g);
-    property_map< graph_t, vertex_predecessor_t >::type p
-        = get(vertex_predecessor, g);
+    auto d = get(vertex_distance, g);
+    auto p = get(vertex_predecessor, g);
    dijkstra_shortest_paths(g, s, predecessor_map(p).distance_map(d));

    std::cout << "distances and parents:" << std::endl;
@@ -87,9 +83,8 @@ int main(int, char*[])
    graph_traits< graph_t >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
--- a/example/dijkstra-example.cpp
+++ b/example/dijkstra-example.cpp
@@ -39,11 +39,10 @@ int main(int, char*[])
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    int num_arcs = sizeof(edge_array) / sizeof(Edge);
    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    std::vector< vertex_descriptor > p(num_vertices(g));
    std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

    dijkstra_shortest_paths(g, s,
        predecessor_map(boost::make_iterator_property_map(
@@ -73,9 +72,8 @@ int main(int, char*[])
    graph_traits< graph_t >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
--- a/example/dijkstra-no-color-map-example.cpp
+++ b/example/dijkstra-no-color-map-example.cpp
@@ -43,11 +43,10 @@ int main(int, char*[])
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    int num_arcs = sizeof(edge_array) / sizeof(Edge);
    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    std::vector< vertex_descriptor > p(num_vertices(g));
    std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

    dijkstra_shortest_paths_no_color_map(g, s,
        predecessor_map(boost::make_iterator_property_map(
@@ -78,8 +77,7 @@ int main(int, char*[])
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
--- a/example/directed_graph.cpp
+++ b/example/directed_graph.cpp
@@ -18,8 +18,8 @@ int main(int, char*[])

    typedef boost::directed_graph<> Graph;
    Graph g;
-    boost::graph_traits< Graph >::vertex_descriptor v0 = g.add_vertex();
-    boost::graph_traits< Graph >::vertex_descriptor v1 = g.add_vertex();
+    auto v0 = g.add_vertex();
+    auto v1 = g.add_vertex();

    g.add_edge(v0, v1);

--- a/example/edge-connectivity.cpp
+++ b/example/edge-connectivity.cpp
@@ -30,7 +30,7 @@ min_degree_vertex(Graph& g)
 {
    typename graph_traits< Graph >::vertex_descriptor p;
    typedef typename graph_traits< Graph >::degree_size_type size_type;
-    size_type delta = (std::numeric_limits< size_type >::max)();
+    auto delta = (std::numeric_limits< size_type >::max)();
    typename graph_traits< Graph >::vertex_iterator i, iend;
    for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
        if (degree(*i, g) < delta)
@@ -86,12 +86,9 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
    std::vector< edge_descriptor > pred(num_vertices(g));

    FlowGraph flow_g(num_vertices(g));
-    typename property_map< FlowGraph, edge_capacity_t >::type cap
-        = get(edge_capacity, flow_g);
-    typename property_map< FlowGraph, edge_residual_capacity_t >::type res_cap
-        = get(edge_residual_capacity, flow_g);
-    typename property_map< FlowGraph, edge_reverse_t >::type rev_edge
-        = get(edge_reverse, flow_g);
+    auto cap = get(edge_capacity, flow_g);
+    auto res_cap = get(edge_residual_capacity, flow_g);
+    auto rev_edge = get(edge_reverse, flow_g);

    typename graph_traits< VertexListGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -139,14 +136,13 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
    }

    std::vector< bool > in_S_star(num_vertices(g), false);
-    typename std::vector< vertex_descriptor >::iterator si;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
-        in_S_star[*si] = true;
+    for (auto const& vertex : S_star.begin())
+        in_S_star[vertex] = true;
    degree_size_type c = 0;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
+    for (auto const& vertex : S_star.begin())
    {
        typename graph_traits< VertexListGraph >::out_edge_iterator ei, ei_end;
-        for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
+        for (boost::tie(ei, ei_end) = out_edges(vertex, g); ei != ei_end; ++ei)
            if (!in_S_star[target(*ei, g)])
            {
                *disconnecting_set++ = *ei;
@@ -166,21 +162,17 @@ int main()
    read_graphviz("figs/edge-connectivity.dot", g);

    typedef graph_traits< GraphvizGraph >::edge_descriptor edge_descriptor;
-    typedef graph_traits< GraphvizGraph >::degree_size_type degree_size_type;
    std::vector< edge_descriptor > disconnecting_set;
-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));

    std::cout << "The edge connectivity is " << c << "." << std::endl;

-    property_map< GraphvizGraph, vertex_attribute_t >::type attr_map
-        = get(vertex_attribute, g);
+    auto attr_map = get(vertex_attribute, g);

    std::cout << "The disconnecting set is {";
-    for (std::vector< edge_descriptor >::iterator i = disconnecting_set.begin();
-         i != disconnecting_set.end(); ++i)
-        std::cout << "(" << attr_map[source(*i, g)]["label"] << ","
-                  << attr_map[target(*i, g)]["label"] << ") ";
+    for (auto const& edge : disconnecting_set)
+        std::cout << "(" << attr_map[source(edge, g)]["label"] << ","
+                  << attr_map[target(edge, g)]["label"] << ") ";
    std::cout << "}." << std::endl;
    return EXIT_SUCCESS;
 }
--- a/example/edge-function.cpp
+++ b/example/edge-function.cpp
@@ -111,12 +111,12 @@ int main(int argc, const char** argv)

    graph_traits< graph_type >::vertex_descriptor yow, zag, bar;
    // Get vertex name property map from the graph
-    typedef property_map< graph_type, vertex_name_t >::type name_map_t;
-    name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    // Get iterators for the vertex set
    graph_traits< graph_type >::vertex_iterator i, end;
    boost::tie(i, end) = vertices(g);
    // Find yow.h
+    using name_map_t = property_map< graph_type, vertex_name_t >::type;
    name_equals_t< name_map_t > predicate1("yow.h", name);
    yow = *std::find_if(i, end, predicate1);
    // Find zag.o
--- a/example/edge_basics.cpp
+++ b/example/edge_basics.cpp
@@ -45,12 +45,12 @@ template < class Graph > struct exercise_edge
    void operator()(Edge e) const
    {
        // begin
-        // Get the associated vertex type out of the edge using the
-        // edge_traits class
-        // Use the source() and target() functions to access the vertices
-        // that belong to Edge e
-        Vertex src = source(e, G);
-        Vertex targ = target(e, G);
+        //  Get the associated vertex type out of the edge using the
+        //  edge_traits class
+        //  Use the source() and target() functions to access the vertices
+        //  that belong to Edge e
+        auto src = source(e, G);
+        auto targ = target(e, G);

        // print out the vertex id's just because
        cout << "(" << src << "," << targ << ") ";
--- a/example/edge_connectivity.cpp
+++ b/example/edge_connectivity.cpp
@@ -49,8 +49,7 @@ int main()
    typedef graph_traits< UndirectedGraph >::degree_size_type degree_size_type;
    std::vector< edge_descriptor > disconnecting_set;

-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));

    std::cout << "The edge connectivity is " << c << "." << std::endl;
    std::cout << "The disconnecting set is {";
--- a/example/edge_iterator_constructor.cpp
+++ b/example/edge_iterator_constructor.cpp
@@ -60,7 +60,7 @@ public:
    }
    edge_stream_iterator operator++(int)
    {
-        edge_stream_iterator tmp = *this;
+        auto tmp = *this;
        m_read();
        return tmp;
    }
--- a/example/edge_property.cpp
+++ b/example/edge_property.cpp
@@ -80,10 +80,8 @@ template < class Graph > void print_network(const Graph& G)
        typename boost::graph_traits< Graph >::out_edge_iterator OutEdgeIter;
    typedef typename boost::graph_traits< Graph >::in_edge_iterator InEdgeIter;

-    typename property_map< Graph, edge_mycapacity_t >::const_type capacity
-        = get(edge_mycapacity, G);
-    typename property_map< Graph, edge_myflow_t >::const_type flow
-        = get(edge_myflow, G);
+    auto capacity = get(edge_mycapacity, G);
+    auto flow = get(edge_myflow, G);

    Viter ui, uiend;
    boost::tie(ui, uiend) = vertices(G);
--- a/example/edmonds-karp-eg.cpp
+++ b/example/edmonds-karp-eg.cpp
@@ -61,11 +61,9 @@ int main()

    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);

    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);
--- a/example/family_tree.cpp
+++ b/example/family_tree.cpp
@@ -38,8 +38,7 @@ int main()

    graph_traits< adjacency_list<> >::vertex_iterator i, end;
    graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);

    for (boost::tie(i, end) = vertices(g); i != end; ++i)
    {
--- a/example/fibonacci_heap.cpp
+++ b/example/fibonacci_heap.cpp
@@ -34,7 +34,7 @@ int main()
        uniform_int<> distrib(0, N - 1);
        boost::variate_generator< random_ns::mt19937&, uniform_int<> > rand_gen(
            gen, distrib);
-        for (int t = 0; t < 10; ++t)
+        for (std::size_t t = 0; t < 10; ++t)
        {
            std::vector< float > v, w(N);

--- a/example/filtered-copy-example.cpp
+++ b/example/filtered-copy-example.cpp
@@ -45,7 +45,7 @@ int main()
        N
    };
    graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
    char name = 'a';
    graph_traits< graph_t >::vertex_iterator v, v_end;
    for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
--- a/example/filtered_graph_edge_range.cpp
+++ b/example/filtered_graph_edge_range.cpp
@@ -65,7 +65,7 @@ int main()
    add_edge(D, B, 3, g);
    add_edge(E, C, 0, g);

-    EdgeWeightMap weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);

    std::cout << "unfiltered edge_range(C,D)\n";
    graph_traits< Graph >::out_edge_iterator f, l;
--- a/example/filtered_vec_as_graph.cpp
+++ b/example/filtered_vec_as_graph.cpp
@@ -45,18 +45,15 @@ int main()
        B,
        C,
        D,
-        E,
-        N
+        E
    };
    const char* name = "ABCDE";
    typedef std::vector< std::list< int > > Graph;
-    Graph g(N);
-    g[A].push_back(B);
-    g[A].push_back(C);
-    g[C].push_back(D);
-    g[C].push_back(E);
-    g[D].push_back(E);
-    g[E].push_back(C);
+    Graph g = { { B, C }, // A
+        {}, // B
+        { D, E }, // C
+        { E }, // D
+        { C } }; // E

    constant_target filter(E);
    filtered_graph< Graph, constant_target > fg(g, filter);
--- a/example/gerdemann.cpp
+++ b/example/gerdemann.cpp
@@ -49,14 +49,14 @@ void merge_vertex(typename boost::graph_traits< Graph >::vertex_descriptor u,
         ++out_i)
    {
        e = *out_i;
-        typename Traits::vertex_descriptor targ = target(e, g);
+        auto targ = target(e, g);
        add_edge(u, targ, getp(e), g);
    }
    typename Traits::in_edge_iterator in_i, in_end;
    for (boost::tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i)
    {
        e = *in_i;
-        typename Traits::vertex_descriptor src = source(e, g);
+        auto src = source(e, g);
        add_edge(src, u, getp(e), g);
    }
    clear_vertex(v, g);
@@ -131,8 +131,8 @@ int main()
    add_edge(3, 4, EdgeProperty('h'), g);
    add_edge(0, 1, EdgeProperty('c'), g);

-    property_map< graph_type, vertex_index_t >::type id = get(vertex_index, g);
-    property_map< graph_type, edge_name_t >::type name = get(edge_name, g);
+    auto id = get(vertex_index, g);
+    auto name = get(edge_name, g);

    graph_traits< graph_type >::vertex_iterator i, end;
    graph_traits< graph_type >::out_edge_iterator ei, edge_end;
--- a/example/girth.cpp
+++ b/example/girth.cpp
@@ -75,7 +75,7 @@ public:

    void tree_edge(edge_descriptor e, Graph* g)
    {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        k = d_map[u] + 1;
        d_map[v] = k;
        ++distance_list[k];
@@ -83,7 +83,7 @@ public:
    }
    void non_tree_edge(edge_descriptor e, Graph* g)
    {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        k = d_map[u] + 1;
        if (d_map[v] + k < girth && v != p_map[u])
            girth = d_map[v] + k;
--- a/example/graph-thingie.cpp
+++ b/example/graph-thingie.cpp
@@ -14,6 +14,7 @@
 #include <boost/foreach.hpp>
 #include <string>
 #include <sstream>
+#include <cstdlib>

 using namespace boost;
 using namespace std;
@@ -51,18 +52,16 @@ int main()
    graph_t graph(0);
    dynamic_properties dp;

-    property_map< graph_t, vertex_name_t >::type vname
-        = get(vertex_name, graph);
+    auto vname = get(vertex_name, graph);
    dp.property("node_id", vname);

-    property_map< graph_t, vertex_label_t >::type vlabel
-        = get(vertex_label_t(), graph);
+    auto vlabel = get(vertex_label_t(), graph);
    dp.property("label", vlabel);

-    property_map< graph_t, vertex_root_t >::type root = get(vertex_root, graph);
+    auto root = get(vertex_root, graph);
    dp.property("root", root);

-    property_map< graph_t, edge_name_t >::type elabel = get(edge_name, graph);
+    auto elabel = get(edge_name, graph);
    dp.property("label", elabel);

    // Use ref_property_map to turn a graph property into a property map
@@ -104,5 +103,5 @@ int main()
             << get("label", dp, v) << ")\n";
    }

-    return 0;
+    return status ? EXIT_SUCCESS : EXIT_FAILURE;
 }
--- a/example/graph_as_tree.cpp
+++ b/example/graph_as_tree.cpp
@@ -39,13 +39,12 @@ int main()

    graph_t g;

-    vertex_t a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);
+    auto a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);

    add_edge(a, b, g);
    add_edge(a, c, g);

-    typedef property_map< graph_t, vertex_name_t >::type vertex_name_map_t;
-    vertex_name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    name[a] = "A";
    name[b] = "B";
    name[c] = "C";
--- a/example/grid_graph_properties.cpp
+++ b/example/grid_graph_properties.cpp
@@ -35,7 +35,7 @@ int main(int argc, char* argv[])
    put(dataMap, v, 2.0f);

    // Get the data at the node at position (0,1) in the grid
-    float retrieved = get(dataMap, v);
+    auto retrieved = get(dataMap, v);
    std::cout << "Retrieved value: " << retrieved << std::endl;

    return 0;
--- a/example/hawick_circuits.cpp
+++ b/example/hawick_circuits.cpp
@@ -28,10 +28,7 @@ template < typename OutputStream > struct cycle_printer

        // Get the property map containing the vertex indices
        // so we can print them.
-        typedef typename boost::property_map< Graph,
-            boost::vertex_index_t >::const_type IndexMap;
-
-        IndexMap indices = get(boost::vertex_index, g);
+        auto indices = get(boost::vertex_index, g);

        // Iterate over path printing each vertex that forms the cycle.
        typename Path::const_iterator i, before_end = boost::prior(p.end());
--- a/example/implicit_graph.cpp
+++ b/example/implicit_graph.cpp
@@ -223,7 +223,7 @@ private:
        static const int ring_offset[] = { 1, -1 };
        vertex_descriptor v;

-        std::size_t p = *this->base_reference();
+        auto p = *this->base_reference();
        if (m_u == 0 && p == 1)
            v = m_n - 1; // Vertex n-1 precedes vertex 0.
        else
--- a/example/influence_prestige.cpp
+++ b/example/influence_prestige.cpp
@@ -63,7 +63,7 @@ int main(int argc, char* argv[])
    graph_traits< Graph >::vertex_iterator i, end;
    for (boost::tie(i, end) = vertices(g); i != end; ++i)
    {
-        Vertex v = *i;
+        auto v = *i;
        cout << setiosflags(ios::left) << setw(12) << g[v].name << "\t" << im[v]
             << "\t" << pm[v] << endl;
    }
--- a/example/interior_property_map.cpp
+++ b/example/interior_property_map.cpp
@@ -61,7 +61,7 @@ void who_owes_who(EdgeIter first, EdgeIter last, const Graph& G)
    // Access the propety acessor type for this graph
    typedef
        typename property_map< Graph, vertex_first_name_t >::const_type NamePA;
-    NamePA name = get(vertex_first_name, G);
+    auto name = get(vertex_first_name, G);

    typedef typename boost::property_traits< NamePA >::value_type NameType;

--- a/example/iteration_macros.cpp
+++ b/example/iteration_macros.cpp
@@ -45,8 +45,7 @@ int main()

    graph_traits< adjacency_list<> >::vertex_iterator i, end;
    graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);

    BGL_FORALL_VERTICES(i, g, adjacency_list<>)
    {
--- a/example/johnson-eg.cpp
+++ b/example/johnson-eg.cpp
@@ -36,7 +36,7 @@ int main()
    Graph g(edge_array, edge_array + E, V);
 #endif

-    property_map< Graph, edge_weight_t >::type w = get(edge_weight, g);
+    auto w = get(edge_weight, g);
    int weights[] = { 0, 0, 0, 0, 0, 3, -4, 8, 1, 7, 4, -5, 2, 6 };
    int* wp = weights;

--- a/example/kevin-bacon.cpp
+++ b/example/kevin-bacon.cpp
@@ -58,10 +58,8 @@ int main(int argc, const char** argv)
        Graph;
    Graph g;

-    typedef property_map< Graph, vertex_name_t >::type actor_name_map_t;
-    actor_name_map_t actor_name = get(vertex_name, g);
-    typedef property_map< Graph, edge_name_t >::type movie_name_map_t;
-    movie_name_map_t connecting_movie = get(edge_name, g);
+    auto actor_name = get(vertex_name, g);
+    auto connecting_movie = get(edge_name, g);

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
    typedef std::map< std::string, Vertex > NameVertexMap;
--- a/example/kevin-bacon2.cpp
+++ b/example/kevin-bacon2.cpp
@@ -65,7 +65,7 @@ public:

    void tree_edge(Edge e, const Graph& g) const
    {
-        Vertex u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        d[v] = d[u] + 1;
    }

--- a/example/king_ordering.cpp
+++ b/example/king_ordering.cpp
@@ -62,26 +62,24 @@ int main(int, char*[])

    graph_traits< Graph >::vertex_iterator ui, ui_end;

-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
        deg[*ui] = degree(*ui, G);

-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);

    std::cout << "original bandwidth: " << bandwidth(G) << std::endl;

    std::vector< Vertex > inv_perm(num_vertices(G));
    std::vector< size_type > perm(num_vertices(G));
    {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
        // king_ordering
        king_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G), get(vertex_index, G));
        cout << "King ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
+        for (auto i = inv_perm.begin(); i != inv_perm.end(); ++i)
            cout << index_map[*i] << " ";
        cout << endl;

@@ -100,9 +98,8 @@ int main(int, char*[])
            get(vertex_degree, G), get(vertex_index, G));
        cout << "King ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])

        cout << "King ordering:" << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
--- a/example/kruskal-example.cpp
+++ b/example/kruskal-example.cpp
@@ -26,7 +26,7 @@ int main()
    std::size_t num_edges = sizeof(edge_array) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    Graph g(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto = get(edge_weight, g);
    for (std::size_t j = 0; j < num_edges; ++j)
    {
        Edge e;
@@ -38,14 +38,14 @@ int main()
 #else
    Graph g(edge_array, edge_array + num_edges, weights, num_nodes);
 #endif
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+
+    auto weight = get(edge_weight, g);
    std::vector< Edge > spanning_tree;

    kruskal_minimum_spanning_tree(g, std::back_inserter(spanning_tree));

    std::cout << "Print the edges in the MST:" << std::endl;
-    for (std::vector< Edge >::iterator ei = spanning_tree.begin();
-         ei != spanning_tree.end(); ++ei)
+    for (auto ei = spanning_tree.begin(); ei != spanning_tree.end(); ++ei)
    {
        std::cout << source(*ei, g) << " <--> " << target(*ei, g)
                  << " with weight of " << weight[*ei] << std::endl;
--- a/example/kruskal-telephone.cpp
+++ b/example/kruskal-telephone.cpp
@@ -30,8 +30,7 @@ int main()
        property< edge_weight_t, int > >
        Graph;
    Graph g(num_vertices(g_dot));
-    property_map< GraphvizGraph, edge_attribute_t >::type edge_attr_map
-        = get(edge_attribute, g_dot);
+    auto edge_attr_map = get(edge_attribute, g_dot);
    graph_traits< GraphvizGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
@@ -45,22 +44,20 @@ int main()
        size_type;
    kruskal_minimum_spanning_tree(g, std::back_inserter(mst));

-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
    int total_weight = 0;
-    for (size_type e = 0; e < mst.size(); ++e)
-        total_weight += get(weight, mst[e]);
+    for (auto const& edge : mst)
+        total_weight += get(weight, edge);
    std::cout << "total weight: " << total_weight << std::endl;

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
-    for (size_type i = 0; i < mst.size(); ++i)
+    for (auto const& edge : mst)
    {
-        Vertex u = source(mst[i], g), v = target(mst[i], g);
+        auto u = source(edge, g), v = target(edge, g);
        edge_attr_map[edge(u, v, g_dot).first]["color"] = "black";
    }
    std::ofstream out("figs/telephone-mst-kruskal.dot");
-    graph_property< GraphvizGraph, graph_edge_attribute_t >::type&
-        graph_edge_attr_map
-        = get_property(g_dot, graph_edge_attribute);
+    auto graph_edge_attr_map = get_property(g_dot, graph_edge_attribute);
    graph_edge_attr_map["color"] = "gray";
    graph_edge_attr_map["style"] = "bold";
    write_graphviz(out, g_dot);
--- a/example/kuratowski_subgraph.cpp
+++ b/example/kuratowski_subgraph.cpp
@@ -45,7 +45,7 @@ int main(int argc, char** argv)
    add_edge(4, 5, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
--- a/example/last-mod-time.cpp
+++ b/example/last-mod-time.cpp
@@ -76,8 +76,7 @@ int main(int argc, const char** argv)
        exit(-1);
    }
    // Obtain internal property map from the graph
-    property_map< graph_type, vertex_name_t >::type name_map
-        = get(vertex_name, g);
+    auto name_map = get(vertex_name, g);
    read_graph_file(file_in, name_in, g, name_map);

    // Create storage for last modified times
@@ -89,7 +88,7 @@ int main(int argc, const char** argv)
    // Create last modified time property map
    iter_map_t mod_time_map(last_mod_vec.begin(), get(vertex_index, g));

-    property_map< graph_type, vertex_name_t >::type name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    struct stat stat_buf;
    graph_traits< graph_type >::vertex_descriptor u;
    typedef graph_traits< graph_type >::vertex_iterator vertex_iter_t;
--- a/example/leda-graph-eg.cpp
+++ b/example/leda-graph-eg.cpp
@@ -19,7 +19,7 @@ int main()
    g.new_node("Eurystheus");
    g.new_node("Amphitryon");
    typedef property_map< graph_t, vertex_all_t >::type NodeMap;
-    NodeMap node_name_map = get(vertex_all, g);
+    auto node_name_map = get(vertex_all, g);
    graph_traits< graph_t >::vertex_iterator vi, vi_end;
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
        std::cout << node_name_map[*vi] << std::endl;
--- a/example/loops_dfs.cpp
+++ b/example/loops_dfs.cpp
@@ -133,20 +133,18 @@ int main(int argc, char* argv[])
    typedef std::set< Vertex > set_t;
    typedef std::list< set_t > list_of_sets_t;
    list_of_sets_t loops;
-    Vertex entry = *vertices(g).first;
+    auto entry = *vertices(g).first;

    find_loops(entry, g, loops);

-    property_map< Graph, vertex_attribute_t >::type vattr_map
-        = get(vertex_attribute, g);
-    property_map< Graph, edge_attribute_t >::type eattr_map
-        = get(edge_attribute, g);
+    auto vattr_map = get(vertex_attribute, g);
+    auto eattr_map = get(edge_attribute, g);
    graph_traits< Graph >::edge_iterator ei, ei_end;

-    for (list_of_sets_t::iterator i = loops.begin(); i != loops.end(); ++i)
+    for (auto i = loops.begin(); i != loops.end(); ++i)
    {
        std::vector< bool > in_loop(num_vertices(g), false);
-        for (set_t::iterator j = (*i).begin(); j != (*i).end(); ++j)
+        for (auto j = (*i).begin(); j != (*i).end(); ++j)
        {
            vattr_map[*j]["color"] = "gray";
            in_loop[*j] = true;
@@ -167,9 +165,7 @@ int main(int argc, char* argv[])
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
    {
        loops_out << *vi << "[";
-        for (std::map< std::string, std::string >::iterator ai
-             = vattr_map[*vi].begin();
-             ai != vattr_map[*vi].end(); ++ai)
+        for (auto ai = vattr_map[*vi].begin(); ai != vattr_map[*vi].end(); ++ai)
        {
            loops_out << ai->first << "=" << ai->second;
            if (next(ai) != vattr_map[*vi].end())
@@ -181,10 +177,8 @@ int main(int argc, char* argv[])
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
        loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
-        std::map< std::string, std::string >& attr_map = eattr_map[*ei];
-        for (std::map< std::string, std::string >::iterator eai
-             = attr_map.begin();
-             eai != attr_map.end(); ++eai)
+        auto& attr_map = eattr_map[*ei];
+        for (auto eai = attr_map.begin(); eai != attr_map.end(); ++eai)
        {
            loops_out << eai->first << "=" << eai->second;
            if (next(eai) != attr_map.end())
--- a/example/make_biconnected_planar.cpp
+++ b/example/make_biconnected_planar.cpp
@@ -41,7 +41,7 @@ int main(int argc, char** argv)
    add_edge(0, 10, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
--- a/example/make_maximal_planar.cpp
+++ b/example/make_maximal_planar.cpp
@@ -60,7 +60,7 @@ int main(int argc, char** argv)
              << 2 * num_vertices(g) - 4 << " faces." << std::endl;

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
--- a/example/matching_example.cpp
+++ b/example/matching_example.cpp
@@ -25,15 +25,14 @@ int main()

    const int n_vertices = 18;

-    std::vector< std::string > ascii_graph;
-
-    ascii_graph.push_back("           0       1---2       3       ");
-    ascii_graph.push_back("            \\     /     \\     /        ");
-    ascii_graph.push_back("             4---5       6---7         ");
-    ascii_graph.push_back("             |   |       |   |         ");
-    ascii_graph.push_back("             8---9      10---11        ");
-    ascii_graph.push_back("            /     \\     /     \\        ");
-    ascii_graph.push_back("     12   13      14---15      16   17 ");
+    std::vector< std::string > ascii_graph
+        = { "           0       1---2       3       ",
+              "            \\     /     \\     /        ",
+              "             4---5       6---7         ",
+              "             |   |       |   |         ",
+              "             8---9      10---11        ",
+              "            /     \\     /     \\        ",
+              "     12   13      14---15      16   17 " };

    // It has a perfect matching of size 8. There are two isolated
    // vertices that we'll use later...
@@ -75,9 +74,8 @@ int main()

    std::cout << "In the following graph:" << std::endl << std::endl;

-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
-        std::cout << *itr << std::endl;
+    for (auto const& str : ascii_graph)
+        std::cout << str << std::endl;

    std::cout << std::endl
              << "Found a matching of size " << matching_size(g, &mate[0])
@@ -106,8 +104,7 @@ int main()

    std::cout << "In the following graph:" << std::endl << std::endl;

-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
+    for (auto itr = ascii_graph.begin(); itr != ascii_graph.end(); ++itr)
        std::cout << *itr << std::endl;

    std::cout << std::endl
--- a/example/max_flow.cpp
+++ b/example/max_flow.cpp
@@ -62,11 +62,9 @@ int main()

    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);

    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);
--- a/example/mcgregor_subgraphs_example.cpp
+++ b/example/mcgregor_subgraphs_example.cpp
@@ -81,14 +81,12 @@ int main(int argc, char* argv[])
        property< edge_name_t, unsigned int > >
        Graph;

-    typedef property_map< Graph, vertex_name_t >::type VertexNameMap;
-
    // Test maximum and unique variants on known graphs
    Graph graph_simple1, graph_simple2;
    example_callback< Graph > user_callback(graph_simple1);

-    VertexNameMap vname_map_simple1 = get(vertex_name, graph_simple1);
-    VertexNameMap vname_map_simple2 = get(vertex_name, graph_simple2);
+    auto vname_map_simple1 = get(vertex_name, graph_simple1);
+    auto vname_map_simple2 = get(vertex_name, graph_simple2);

    // Graph that looks like a triangle
    put(vname_map_simple1, add_vertex(graph_simple1), 1);
--- a/example/mean_geodesic.cpp
+++ b/example/mean_geodesic.cpp
@@ -71,7 +71,7 @@ int main(int argc, char* argv[])
    // so-called small-world distance) as a result.
    GeodesicContainer geodesics(num_vertices(g));
    GeodesicMap gm(geodesics, g);
-    float sw = all_mean_geodesics(g, dm, gm);
+    auto sw = all_mean_geodesics(g, dm, gm);

    // Print the mean geodesic distance of each vertex and finally,
    // the graph itself.
--- a/example/miles_span.cpp
+++ b/example/miles_span.cpp
@@ -102,11 +102,9 @@ int main(int argc, char* argv[])
        long sp_length = 0;

        // Use the "z" utility field for distance.
-        typedef property_map< Graph*, z_property< long > >::type Distance;
-        Distance d = get(z_property< long >(), g);
+        auto d = get(z_property< long >(), g);
        // Use the "w" property for parent
-        typedef property_map< Graph*, w_property< Vertex* > >::type Parent;
-        Parent p = get(w_property< Vertex* >(), g);
+        auto p = get(w_property< Vertex* >(), g);
        total_length_visitor< Distance > length_vis(sp_length, d);

        prim_minimum_spanning_tree(g, p,
--- a/example/min_max_paths.cpp
+++ b/example/min_max_paths.cpp
@@ -52,14 +52,14 @@ int main(int, char*[])
    const char name[] = "abcdef";

    const int num_nodes = 6;
-    E edges[] = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3), E(3, 4),
-        E(4, 0), E(4, 1) };
+    const auto edges = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3),
+        E(3, 4), E(4, 0), E(4, 1) };
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    const int n_edges = sizeof(edges) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // VC++ can't handle iterator constructors
    Graph G(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    auto weightmap = get(edge_weight, G);
    for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j)
    {
        graph_traits< Graph >::edge_descriptor e;
@@ -68,8 +68,8 @@ int main(int, char*[])
        weightmap[e] = weights[j];
    }
 #else
-    Graph G(edges, edges + n_edges, weights, num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    Graph G(std::begin(edges), std::end(edges), weights, num_nodes);
+    auto = get(edge_weight, G);
 #endif

    std::vector< Vertex > p(num_vertices(G));
--- a/example/minimum_degree_ordering.cpp
+++ b/example/minimum_degree_ordering.cpp
@@ -146,8 +146,7 @@ int main(int argc, char* argv[])

    Vector supernode_sizes(n, 1); // init has to be 1

-    boost::property_map< Graph, vertex_index_t >::type id
-        = get(vertex_index, G);
+    auto id = get(vertex_index, G);

    Vector degree(n, 0);

--- a/example/modify_graph.cpp
+++ b/example/modify_graph.cpp
@@ -47,8 +47,7 @@ template < class MutableGraph > void modify_demo(MutableGraph& g)
    typename GraphTraits::edges_size_type m = 0;
    typename GraphTraits::vertex_descriptor u, v, w;
    edge_descriptor e, e1, e2;
-    typename property_map< MutableGraph, edge_name_t >::type name_map
-        = get(edge_name, g);
+    auto name_map = get(edge_name, g);
    bool added;
    typename GraphTraits::vertex_iterator vi, vi_end;

--- a/example/neighbor_bfs.cpp
+++ b/example/neighbor_bfs.cpp
@@ -65,16 +65,14 @@ public:
    template < class Edge, class Graph >
    void tree_out_edge(Edge e, const Graph& g) const
    {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        put(m_distance, v, get(m_distance, u) + 1);
        put(m_predecessor, v, u);
    }
    template < class Edge, class Graph >
    void tree_in_edge(Edge e, const Graph& g) const
    {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        put(m_distance, u, get(m_distance, v) + 1);
        put(m_predecessor, u, v);
    }
--- a/example/ordered_out_edges.cpp
+++ b/example/ordered_out_edges.cpp
@@ -112,8 +112,8 @@ int main()
    add_edge(3, 4, EdgeProperty("harry"), g);
    add_edge(0, 1, EdgeProperty("chandler"), g);

-    property_map< graph_type, vertex_index_t >::type id = get(vertex_index, g);
-    property_map< graph_type, edge_name_t >::type name = get(edge_name, g);
+    auto id = get(vertex_index, g);
+    auto name = get(edge_name, g);

    graph_traits< graph_type >::vertex_iterator i, end;
    graph_traits< graph_type >::out_edge_iterator ei, edge_end;
--- a/example/ospf-example.cpp
+++ b/example/ospf-example.cpp
@@ -49,7 +49,7 @@ int main(int argc, const char** argv)
    graph_traits< g_dot_type >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
-        int weight = get(edge_weight, g_dot, *ei);
+        auto weight = get(edge_weight, g_dot, *ei);
        property< edge_weight_t, int > edge_property(weight);
        add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
    }
@@ -71,8 +71,8 @@ int main(int argc, const char** argv)

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    std::vector< int > distance(num_vertices(g));
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto weightmap = get(edge_weight, g);
+    auto indexmap = get(vertex_index, g);
    dijkstra_shortest_paths(g, router_six, &parent[0], &distance[0], weightmap,
        indexmap, std::less< int >(), closed_plus< int >(),
        (std::numeric_limits< int >::max)(), 0, default_dijkstra_visitor());
--- a/example/planar_face_traversal.cpp
+++ b/example/planar_face_traversal.cpp
@@ -71,7 +71,7 @@ int main(int argc, char** argv)
    add_edge(5, 8, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
--- a/example/prim-example.cpp
+++ b/example/prim-example.cpp
@@ -18,12 +18,12 @@ int main()
        Graph;
    typedef std::pair< int, int > E;
    const int num_nodes = 5;
-    E edges[]
+    const auto edges
        = { E(0, 2), E(1, 3), E(1, 4), E(2, 1), E(2, 3), E(3, 4), E(4, 0) };
    int weights[] = { 1, 1, 2, 7, 3, 1, 1 };
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    Graph g(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j)
    {
        graph_traits< Graph >::edge_descriptor e;
@@ -32,14 +32,13 @@ int main()
        weightmap[e] = weights[j];
    }
 #else
-    Graph g(edges, edges + sizeof(edges) / sizeof(E), weights, num_nodes);
+    Graph g(std::begin(edges), std::end(edges), weights, num_nodes);
 #endif
    std::vector< graph_traits< Graph >::vertex_descriptor > p(num_vertices(g));

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_distance_t >::type distance
-        = get(vertex_distance, g);
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto distance = get(vertex_distance, g);
+    auto indexmap = get(vertex_index, g);
    prim_minimum_spanning_tree(g, *vertices(g).first, &p[0], distance,
        weightmap, indexmap, default_dijkstra_visitor());
 #else
--- a/example/prim-telephone.cpp
+++ b/example/prim-telephone.cpp
@@ -30,21 +30,20 @@ int main()
        property< edge_weight_t, int > >
        Graph;
    Graph g(num_vertices(g_dot));
-    property_map< GraphvizGraph, edge_attribute_t >::type edge_attr_map
-        = get(edge_attribute, g_dot);
+    auto edge_attr_map = get(edge_attribute, g_dot);
    graph_traits< GraphvizGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
-        int weight = lexical_cast< int >(edge_attr_map[*ei]["label"]);
+        auto weight = lexical_cast< int >(edge_attr_map[*ei]["label"]);
        property< edge_weight_t, int > edge_property(weight);
        add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
    }

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
    std::vector< Vertex > parent(num_vertices(g));
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto indexmap = get(vertex_index, g);
    std::vector< std::size_t > distance(num_vertices(g));
    prim_minimum_spanning_tree(g, *vertices(g).first, &parent[0], &distance[0],
        weight, indexmap, default_dijkstra_visitor());
@@ -53,12 +52,12 @@ int main()
 #endif

    int total_weight = 0;
-    for (int v = 0; v < num_vertices(g); ++v)
+    for (std::size_t v = 0; v < num_vertices(g); ++v)
        if (parent[v] != v)
            total_weight += get(weight, edge(parent[v], v, g).first);
    std::cout << "total weight: " << total_weight << std::endl;

-    for (int u = 0; u < num_vertices(g); ++u)
+    for (std::size_t u = 0; u < num_vertices(g); ++u)
        if (parent[u] != u)
            edge_attr_map[edge(parent[u], u, g_dot).first]["color"] = "black";
    std::ofstream out("figs/telephone-mst-prim.dot");
--- a/example/property-map-traits-eg.cpp
+++ b/example/property-map-traits-eg.cpp
@@ -17,7 +17,7 @@ int main()
        graph_t;
    graph_t g;
    graph_traits< graph_t >::vertex_descriptor u = add_vertex(g);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, g);
+    auto name_map = get(vertex_name, g);
    name_map[u] = "Joe";
    std::cout << name_map[u] << std::endl;
    return EXIT_SUCCESS;
--- a/example/property_iterator.cpp
+++ b/example/property_iterator.cpp
@@ -106,14 +106,12 @@ int main(int argc, char* argv[])
    std::cout << write(graph);

    std::cout << "radii:" << std::endl;
-    graph_property_iter_range< Graph, radius_t >::type seqRadius
-        = get_property_iter_range(graph, radius_t());
+    auto seqRadius = get_property_iter_range(graph, radius_t());
    std::for_each(seqRadius.first, seqRadius.second, Print());
    std::cout << std::endl;

    std::cout << "stiff:" << std::endl;
-    graph_property_iter_range< Graph, stiff_t >::type seqStiff
-        = get_property_iter_range(graph, stiff_t());
+    auto seqStiff = get_property_iter_range(graph, stiff_t());
    std::for_each(seqStiff.first, seqStiff.second, Print());
    std::cout << std::endl;

--- a/example/push-relabel-eg.cpp
+++ b/example/push-relabel-eg.cpp
@@ -56,20 +56,17 @@ int main()
        Graph;
    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
+    auto rev = get(edge_reverse, g);
    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
-    long flow = push_relabel_max_flow(
+    auto flow = push_relabel_max_flow(
        g, s, t, capacity, residual_capacity, rev, indexmap);
 #else
-    long flow = push_relabel_max_flow(g, s, t);
+    auto flow = push_relabel_max_flow(g, s, t);
 #endif

    std::cout << "c  The total flow:" << std::endl;
--- a/example/quick-tour.cpp
+++ b/example/quick-tour.cpp
@@ -32,8 +32,7 @@ void print_vertex_names(const Graph& g, VertexNameMap name_map)
 {
    std::cout << "vertices(g) = { ";
    typedef typename graph_traits< Graph >::vertex_iterator iter_t;
-    for (std::pair< iter_t, iter_t > p = vertices(g); p.first != p.second;
-         ++p.first)
+    for (auto p = vertices(g); p.first != p.second; ++p.first)
    {
        print_vertex_name(*p.first, name_map);
        std::cout << ' ';
@@ -95,9 +94,8 @@ int main()
        graph_t;
    graph_t g;

-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, g);
-    property_map< graph_t, edge_weight_t >::type delay_map
-        = get(edge_weight, g);
+    auto name_map = get(vertex_name, g);
+    auto delay_map = get(edge_weight, g);

    build_router_network(g, name_map, delay_map);
    print_vertex_names(g, name_map);
--- a/example/quick_tour.cpp
+++ b/example/quick_tour.cpp
@@ -24,8 +24,7 @@ template < class Graph > struct exercise_vertex
    void operator()(const Vertex& v) const
    {
        using namespace boost;
-        typename property_map< Graph, vertex_index_t >::type vertex_id
-            = get(vertex_index, g);
+        auto vertex_id = get(vertex_index, g);
        std::cout << "vertex: " << name[get(vertex_id, v)] << std::endl;

        // Write out the outgoing edges
@@ -36,7 +35,7 @@ template < class Graph > struct exercise_vertex
             ++out_i)
        {
            e = *out_i;
-            Vertex src = source(e, g), targ = target(e, g);
+            auto src = source(e, g), targ = target(e, g);
            std::cout << "(" << name[get(vertex_id, src)] << ","
                      << name[get(vertex_id, targ)] << ") ";
        }
@@ -106,7 +105,7 @@ int main(int, char*[])
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // VC++ can't handle the iterator constructor
    Graph g(num_vertices);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    for (std::size_t j = 0; j < num_edges; ++j)
    {
        graph_traits< Graph >::edge_descriptor e;
--- a/example/reachable-loop-head.cpp
+++ b/example/reachable-loop-head.cpp
@@ -42,8 +42,7 @@ int main(int argc, char* argv[])
        make_iterator_property_map(
            reachable_from_head.begin(), get(vertex_index, g), c));

-    property_map< GraphvizDigraph, vertex_attribute_t >::type vattr_map
-        = get(vertex_attribute, g);
+    auto vattr_map = get(vertex_attribute, g);

    graph_traits< GraphvizDigraph >::vertex_iterator i, i_end;
    for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
@@ -64,9 +63,7 @@ int main(int argc, char* argv[])
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
    {
        loops_out << *vi << "[";
-        for (std::map< std::string, std::string >::iterator ai
-             = vattr_map[*vi].begin();
-             ai != vattr_map[*vi].end(); ++ai)
+        for (auto ai = vattr_map[*vi].begin(); ai != vattr_map[*vi].end(); ++ai)
        {
            loops_out << ai->first << "=" << ai->second;
            if (next(ai) != vattr_map[*vi].end())
@@ -81,9 +78,7 @@ int main(int argc, char* argv[])
    {
        loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
        std::map< std::string, std::string >& attr_map = eattr_map[*ei];
-        for (std::map< std::string, std::string >::iterator eai
-             = attr_map.begin();
-             eai != attr_map.end(); ++eai)
+        for (auto eai = attr_map.begin(); eai != attr_map.end(); ++eai)
        {
            loops_out << eai->first << "=" << eai->second;
            if (next(eai) != attr_map.end())
--- a/example/reachable-loop-tail.cpp
+++ b/example/reachable-loop-tail.cpp
@@ -56,8 +56,7 @@ int main(int argc, char* argv[])
              << "  node [shape=\"box\"];\n"
              << "  edge [style=\"bold\"];\n";

-    property_map< Graph, vertex_attribute_t >::type vattr_map
-        = get(vertex_attribute, g);
+    auto vattr_map = get(vertex_attribute, g);
    graph_traits< GraphvizDigraph >::vertex_iterator i, i_end;
    for (boost::tie(i, i_end) = vertices(g_in); i != i_end; ++i)
    {
--- a/example/read_graphviz.cpp
+++ b/example/read_graphviz.cpp
@@ -35,15 +35,13 @@ int main()
    graph_t graph(0);
    dynamic_properties dp;

-    property_map< graph_t, vertex_name_t >::type name = get(vertex_name, graph);
+    auto name = get(vertex_name, graph);
    dp.property("node_id", name);

-    property_map< graph_t, vertex_color_t >::type mass
-        = get(vertex_color, graph);
+    auto mass = get(vertex_color, graph);
    dp.property("mass", mass);

-    property_map< graph_t, edge_weight_t >::type weight
-        = get(edge_weight, graph);
+    auto weight = get(edge_weight, graph);
    dp.property("weight", weight);

    // Use ref_property_map to turn a graph property into a property map
--- a/example/read_write_dimacs-eg.cpp
+++ b/example/read_write_dimacs-eg.cpp
@@ -78,10 +78,8 @@ int main()
    typedef property_map< Graph, edge_capacity_t >::type tCapMap;
    typedef tCapMap::value_type tCapMapValue;

-    typedef property_map< Graph, edge_reverse_t >::type tRevEdgeMap;
-
-    tCapMap capacity = get(edge_capacity, g);
-    tRevEdgeMap rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);

    vertex_descriptor s, t;
    /*reading the graph from stdin*/
@@ -95,8 +93,8 @@ int main()
    out_edge_iterator oei, oe_end;
    for (boost::tie(oei, oe_end) = out_edges(s, g); oei != oe_end; ++oei)
    {
-        edge_descriptor from_source = *oei;
-        vertex_descriptor v = target(from_source, g);
+        auto from_source = *oei;
+        auto v = target(from_source, g);
        edge_descriptor to_sink;
        bool is_there;
        boost::tie(to_sink, is_there) = edge(v, t, g);
@@ -104,7 +102,7 @@ int main()
        {
            if (get(capacity, to_sink) > get(capacity, from_source))
            {
-                tCapMapValue to_augment = get(capacity, from_source);
+                auto to_augment = get(capacity, from_source);
                capacity[from_source] = 0;
                capacity[to_sink] -= to_augment;
                augmented_flow += to_augment;
--- a/example/remove_edge_if_bidir.cpp
+++ b/example/remove_edge_if_bidir.cpp
@@ -50,7 +50,7 @@ struct has_weight_greater_than
    bool operator()(graph_traits< Graph >::edge_descriptor e)
    {
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-        property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+        auto weight = get(edge_weight, g);
        return get(weight, e) > w;
 #else
        // This version of get() breaks VC++
@@ -81,7 +81,7 @@ int main()
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        weight[*ei] = ++w;

-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto indexmap = get(vertex_index, g);

    std::cout << "original graph:" << std::endl;
    print_graph(g, indexmap);
--- a/example/remove_edge_if_dir.cpp
+++ b/example/remove_edge_if_dir.cpp
@@ -41,17 +41,10 @@ typedef adjacency_list< vecS, vecS, directedS > Graph;
 int main()
 {
    typedef std::pair< std::size_t, std::size_t > Edge;
-    Edge edges[6] = { Edge(0, 3), Edge(0, 2), Edge(0, 3), Edge(1, 3),
+    const auto edges = { Edge(0, 3), Edge(0, 2), Edge(0, 3), Edge(1, 3),
        Edge(2, 0), Edge(3, 2) };

-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    // VC++ can't handle iterator constructor
-    Graph g(4);
-    for (std::size_t j = 0; j < 6; ++j)
-        add_edge(edges[j].first, edges[j].second, g);
-#else
-    Graph g(edges, edges + 6, 4);
-#endif
+    Graph g(std::begin(edges), std::end(edges), 4);

    std::cout << "original graph:" << std::endl;
    print_graph(g, get(vertex_index, g));
--- a/Show More
+++ b/Show More