diff --git a/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs b/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
index b2c30b51f..651178112 100644
--- a/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/ShortestPath/YenShortestPathsAlgorithm.cs
@@ -16,6 +16,95 @@ namespace QuikGraph.Algorithms.ShortestPath
     /// <typeparam name="TVertex">Vertex type.</typeparam>
     public class YenShortestPathsAlgorithm<TVertex>
     {
+        /// <summary>
+        /// Struct provides the parameters used for the path inspection.
+        /// </summary>
+        public struct InspectPathParameters
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="InspectPathParameters"/> struct.
+            /// </summary>
+            public InspectPathParameters(SortedPath path, IEnumerable<SortedPath> shortestPaths, IEnumerable<SortedPath> acceptedPaths)
+            {
+                Path = path;
+                ShortestPaths = shortestPaths;
+                AcceptedPaths = acceptedPaths;
+            }
+
+            /// <summary>
+            /// The current found shortest path.
+            /// </summary>
+            public SortedPath Path { get; }
+
+            /// <summary>
+            /// All shortest paths found so far. They might were accepted or not. Includes the current found path.
+            /// </summary>
+            public IEnumerable<SortedPath> ShortestPaths { get; }
+
+            /// <summary>
+            /// All shortest paths that were accepted so far.
+            /// </summary>
+            public IEnumerable<SortedPath> AcceptedPaths { get; }
+        }
+
+        /// <summary>
+        /// Struct provides the result of the path inspection.
+        /// </summary>
+        public struct InspectPathResult
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="InspectPathResult"/> struct.
+            /// </summary>
+            public InspectPathResult(PathAcceptance pathAcceptance, SearchContinuation searchContinuation)
+            {
+                PathAcceptance = pathAcceptance;
+                SearchContinuation = searchContinuation;
+            }
+
+            /// <summary>
+            /// Decides whether to add the found path to the result set.
+            /// </summary>
+            public PathAcceptance PathAcceptance { get; }
+
+            /// <summary>
+            /// Decide whether to stop searching for more paths.
+            /// </summary>
+            public SearchContinuation SearchContinuation { get; }
+        }
+
+        /// <summary>
+        /// After path inspection, decide whether to add the found path to the result set.
+        /// </summary>
+        public enum PathAcceptance
+        {
+            /// <summary>
+            /// The found shortest path will be added to the result list.
+            /// </summary>
+            Accept,
+
+            /// <summary>
+            /// The found shortest path will not be added to the result list.
+            /// </summary>
+            Reject
+        }
+
+        /// <summary>
+        /// After path inspection, decide whether to stop searching for more paths.
+        /// </summary>
+        [Flags]
+        public enum SearchContinuation
+        {
+            /// <summary>
+            /// Continue the search until the k shortest paths are found
+            /// </summary>
+            Continue,
+
+            /// <summary>
+            /// The the search and return the found paths even if not k iterations have been done.
+            /// </summary>
+            StopSearch
+        }
+
         /// <summary>
         /// Class representing a sorted path.
         /// </summary>
@@ -109,6 +198,9 @@ IEnumerator IEnumerable.GetEnumerator()
         [NotNull]
         private readonly Func<IEnumerable<SortedPath>, IEnumerable<SortedPath>> _filter;
 
+        [NotNull]
+        private readonly Func<InspectPathParameters, InspectPathResult> _inspectPath;
+
         // Limit for the amount of paths
         private readonly int _k;
 
@@ -127,6 +219,7 @@ IEnumerator IEnumerable.GetEnumerator()
         /// <param name="k">Maximum number of path to search.</param>
         /// <param name="edgeWeights">Optional function that computes the weight for a given edge.</param>
         /// <param name="filter">Optional filter of found paths.</param>
+        /// <param name="inspectPath">Optional function to inspect a found shortest path right after it was found.</param>
         /// <exception cref="T:System.ArgumentNullException"><paramref name="graph"/> is <see langword="null"/>.</exception>
         /// <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
         /// <exception cref="T:System.ArgumentNullException"><paramref name="target"/> is <see langword="null"/>.</exception>
@@ -139,7 +232,8 @@ public YenShortestPathsAlgorithm(
             [NotNull] TVertex target,
             int k,
             [CanBeNull] Func<EquatableTaggedEdge<TVertex, double>, double> edgeWeights = null,
-            [CanBeNull] Func<IEnumerable<SortedPath>, IEnumerable<SortedPath>> filter = null)
+            [CanBeNull] Func<IEnumerable<SortedPath>, IEnumerable<SortedPath>> filter = null,
+            [CanBeNull] Func<InspectPathParameters, InspectPathResult> inspectPath = null)
         {
             if (graph is null)
                 throw new ArgumentNullException(nameof(graph));
@@ -160,6 +254,7 @@ public YenShortestPathsAlgorithm(
             _graph = graph.Clone();
             _weights = edgeWeights ?? DefaultGetWeights;
             _filter = filter ?? DefaultFilter;
+            _inspectPath = inspectPath ?? DefaultInspectPath;
         }
 
         [Pure]
@@ -175,6 +270,12 @@ private static double DefaultGetWeights([NotNull] EquatableTaggedEdge<TVertex, d
             return edge.Tag;
         }
 
+        [Pure]
+        private static InspectPathResult DefaultInspectPath(InspectPathParameters inspectPathParameters)
+        {
+            return new InspectPathResult(PathAcceptance.Accept, SearchContinuation.Continue);
+        }
+
         [Pure]
         private double GetPathDistance([ItemNotNull] SortedPath edges)
         {
@@ -327,19 +428,48 @@ public IEnumerable<SortedPath> Execute()
         {
             SortedPath initialPath = GetInitialShortestPath();
             var shortestPaths = new List<SortedPath> { initialPath };
+            var acceptedPaths = new List<SortedPath>();
+
+            InspectPathResult inspectPathResult = _inspectPath(new InspectPathParameters(initialPath, shortestPaths, acceptedPaths));
+
+            if (inspectPathResult.PathAcceptance == PathAcceptance.Accept)
+            {
+                acceptedPaths.Add(initialPath);
+            }
+
+            if (inspectPathResult.SearchContinuation == SearchContinuation.StopSearch)
+            {
+                return _filter(acceptedPaths);
+            }
 
             // Initialize the set to store the potential k-th shortest path
             var shortestPathCandidates = new BinaryQueue<SortedPath, double>(GetPathDistance);
+            var previousPath = initialPath;
 
             for (int k = 1; k < _k; ++k)
             {
-                SortedPath previousPath = shortestPaths[k - 1];
-
                 if (!SearchAndAddKthShortestPath(previousPath, shortestPaths, shortestPathCandidates))
+                {
                     break;
+                }
+
+                SortedPath newPath = shortestPaths[k];
+                inspectPathResult = _inspectPath(new InspectPathParameters(newPath, shortestPaths, acceptedPaths));
+
+                if (inspectPathResult.PathAcceptance == PathAcceptance.Accept)
+                {
+                    acceptedPaths.Add(newPath);
+                }
+
+                if (inspectPathResult.SearchContinuation == SearchContinuation.StopSearch)
+                {
+                    break;
+                }
+
+                previousPath = newPath;
             }
 
-            return _filter(shortestPaths);
+            return _filter(acceptedPaths);
         }
 
         [NotNull, ItemNotNull]
diff --git a/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs b/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
index 895df5296..e55a74fd1 100644
--- a/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
+++ b/tests/QuikGraph.Tests/Algorithms/ShortestPath/YenShortestPathsAlgorithmTests.cs
@@ -365,6 +365,142 @@ void RunYenAndCheck(YenShortestPathsAlgorithm<char> yen)
             #endregion
         }
 
+        [Test]
+        public void InspectPath_RejectSomePaths()
+        {
+            var graph = new AdjacencyGraph<string, EquatableTaggedEdge<string, double>>(false);
+            graph.AddVertexRange(new[] { "A", "B", "C", "D" });
+            var edges = new[]
+            {
+                new EquatableTaggedEdge<string, double>("A", "B", 5),
+                new EquatableTaggedEdge<string, double>("A", "C", 6),
+                new EquatableTaggedEdge<string, double>("B", "C", 7),
+                new EquatableTaggedEdge<string, double>("B", "D", 8),
+                new EquatableTaggedEdge<string, double>("C", "D", 9)
+            };
+            graph.AddEdgeRange(edges);
+
+            // ignore all paths where "B" comes in the 2nd position
+            var algorithm = new YenShortestPathsAlgorithm<string>(graph, "A", "D", 5, inspectPath: InspectPath);
+            YenShortestPathsAlgorithm<string>.SortedPath[] paths = algorithm.Execute().ToArray();
+
+            // Expecting to find 3 paths:
+            // * => A-B-D (gets ignored)
+            // 1 => A-C-D
+            // * => A-B-C-D (gets ignored)
+            // Consistently checking the result
+            Assert.AreEqual(1, paths.Length);
+            // 1
+            EquatableTaggedEdge<string, double>[] path0 = paths[0].ToArray();
+            Assert.AreEqual(path0[0], edges[1]);
+            Assert.AreEqual(path0[1], edges[4]);
+
+            #region Local functions
+
+            YenShortestPathsAlgorithm<string>.InspectPathResult InspectPath(YenShortestPathsAlgorithm<string>.InspectPathParameters inspectPathParameters)
+            {
+                var pathAcceptance = inspectPathParameters.Path.GetVertex(1) == "B"
+                    ? YenShortestPathsAlgorithm<string>.PathAcceptance.Reject
+                    : YenShortestPathsAlgorithm<string>.PathAcceptance.Accept;
+
+                return new YenShortestPathsAlgorithm<string>.InspectPathResult(pathAcceptance, YenShortestPathsAlgorithm<string>.SearchContinuation.Continue);
+            }
+
+            #endregion
+        }
+
+        [Test]
+        public void InspectPath_StopsSearchWhenConditionIsMet_ForInitialShortestPath()
+        {
+            var graph = new AdjacencyGraph<string, EquatableTaggedEdge<string, double>>(false);
+            graph.AddVertexRange(new[] { "A", "B", "C", "D" });
+            var edges = new[]
+            {
+                new EquatableTaggedEdge<string, double>("A", "B", 5),
+                new EquatableTaggedEdge<string, double>("A", "C", 6),
+                new EquatableTaggedEdge<string, double>("B", "C", 7),
+                new EquatableTaggedEdge<string, double>("B", "D", 8),
+                new EquatableTaggedEdge<string, double>("C", "D", 9)
+            };
+            graph.AddEdgeRange(edges);
+
+            // stop when we have found a shortest path that exceeds some costs
+            var algorithm = new YenShortestPathsAlgorithm<string>(graph, "A", "D", 10, inspectPath: InspectPath);
+            YenShortestPathsAlgorithm<string>.SortedPath[] paths = algorithm.Execute().ToArray();
+
+            // Expecting to get 3 paths:
+            // 1 => A-B-D (cost = 13)
+            // * => A-C-D (path limit reached)
+            // * => A-B-C-D (path limit reached)
+            // Consistently checking the result
+            Assert.AreEqual(1, paths.Length);
+            // 1
+            EquatableTaggedEdge<string, double>[] path0 = paths[0].ToArray();
+            Assert.AreEqual(path0[0], edges[0]);
+            Assert.AreEqual(path0[1], edges[3]);
+
+            #region Local functions
+
+            YenShortestPathsAlgorithm<string>.InspectPathResult InspectPath(YenShortestPathsAlgorithm<string>.InspectPathParameters inspectPathParameters)
+            {
+                var searchContinuation = inspectPathParameters.Path.Sum(x => x.Tag) >= 10
+                    ? YenShortestPathsAlgorithm<string>.SearchContinuation.StopSearch
+                    : YenShortestPathsAlgorithm<string>.SearchContinuation.Continue;
+
+                return new YenShortestPathsAlgorithm<string>.InspectPathResult(YenShortestPathsAlgorithm<string>.PathAcceptance.Accept, searchContinuation);
+            }
+
+            #endregion
+        }
+
+        [Test]
+        public void InspectPath_StopsSearchWhenConditionIsMet_ForNthShortestPath()
+        {
+            var graph = new AdjacencyGraph<string, EquatableTaggedEdge<string, double>>(false);
+            graph.AddVertexRange(new[] { "A", "B", "C", "D" });
+            var edges = new[]
+            {
+                new EquatableTaggedEdge<string, double>("A", "B", 5),
+                new EquatableTaggedEdge<string, double>("A", "C", 6),
+                new EquatableTaggedEdge<string, double>("B", "C", 7),
+                new EquatableTaggedEdge<string, double>("B", "D", 8),
+                new EquatableTaggedEdge<string, double>("C", "D", 9)
+            };
+            graph.AddEdgeRange(edges);
+
+            // stop when we have found a shortest path that exceeds some costs
+            var algorithm = new YenShortestPathsAlgorithm<string>(graph, "A", "D", 10, inspectPath: InspectPath);
+            YenShortestPathsAlgorithm<string>.SortedPath[] paths = algorithm.Execute().ToArray();
+
+            // Expecting to get 3 paths:
+            // 1 => A-B-D (cost = 13)
+            // 2 => A-C-D (cost = 15)
+            // * => A-B-C-D (path limit reached)
+            // Consistently checking the result
+            Assert.AreEqual(2, paths.Length);
+            // 1
+            EquatableTaggedEdge<string, double>[] path0 = paths[0].ToArray();
+            Assert.AreEqual(path0[0], edges[0]);
+            Assert.AreEqual(path0[1], edges[3]);
+            // 2
+            EquatableTaggedEdge<string, double>[] path1 = paths[1].ToArray();
+            Assert.AreEqual(path1[0], edges[1]);
+            Assert.AreEqual(path1[1], edges[4]);
+
+            #region Local functions
+
+            YenShortestPathsAlgorithm<string>.InspectPathResult InspectPath(YenShortestPathsAlgorithm<string>.InspectPathParameters inspectPathParameters)
+            {
+                var searchContinuation = inspectPathParameters.Path.Sum(x => x.Tag) >= 15
+                    ? YenShortestPathsAlgorithm<string>.SearchContinuation.StopSearch
+                    : YenShortestPathsAlgorithm<string>.SearchContinuation.Continue;
+
+                return new YenShortestPathsAlgorithm<string>.InspectPathResult(YenShortestPathsAlgorithm<string>.PathAcceptance.Accept, searchContinuation);
+            }
+
+            #endregion
+        }
+
         [Test]
         public void SortedPathHashCode()
         {