IDDFSFinder seems much better.

Author: coderodde

src/main/java/io/github/coderodde/pathfinding/app/SettingsPane.java

@@ -549,6 +549,15 @@ private SearchStatistics computeSearchStatistics() {
                         SearchStatistics.LabelSelector.VISITED,
                         SearchStatistics.LabelSelector.REJECTED);
 
+            case "IDDFSFinder":
+                return new SearchStatistics(
+                        labelVisitedCount,
+                        labelOpenedCount,
+                        labelTracedCount,
+                        labelRejectedCount,
+                        SearchStatistics.LabelSelector.VISITED,
+                        SearchStatistics.LabelSelector.TRACED);
+                
             default:
                 throw new IllegalStateException("Should not get here ever");
         } 

src/main/java/io/github/coderodde/pathfinding/finders/IDDFSFinder.java

@@ -17,11 +17,17 @@
 /**
  *
  * @author Rodion "rodde" Efremov
- * @version 1.0.0
- * @since 1.0.0
+ * @version 1.0.0 (Sep 13, 2025)
+ * @since 1.0.0 (Sep 13, 2025)
  */
 public final class IDDFSFinder implements Finder {
 
+    private enum Result {
+        FOUND,
+        CUTOFF,
+        FAIL,
+    }
+    
     @Override
     public List<Cell> findPath(GridModel model, 
                                GridCellNeighbourIterable neighbourIterable, 
@@ -32,123 +38,116 @@ public List<Cell> findPath(GridModel model,
         Cell source = model.getSourceGridCell();
         Cell target = model.getTargetGridCell();
 
-        SolutionFound solutionFound = new SolutionFound();
-        Set<Cell> visited = new HashSet<>();
-        List<Cell> tentativePath = new ArrayList<>();
-        List<Cell> optimalPath = new ArrayList<>();
-        int previousVisitedSize = 0;
+        Set<Cell> onPath = new HashSet<>();
+        List<Cell> path = new ArrayList<>();
 
         for (int depth = 0;; ++depth) {
-            depthLimitedSearch(source,
+            if (searchState.haltRequested()) {
+                return List.of();
+            }
+            
+            while (searchState.pauseRequested()) {
+                searchSleep(pathfindingSettings);
+                
+                if (searchState.haltRequested()) {
+                    return List.of();
+                }
+            }
+            
+            path.clear();
+            onPath.clear();
+            
+            Result result = depthLimitedSearch(
+                               source,
                                target,
                                depth, 
-                               solutionFound, 
-                               tentativePath,
-                               optimalPath, 
-                               visited,
+                               path,
+                               onPath,
                                model,
                                neighbourIterable, 
                                pathfindingSettings, 
                                searchState, 
                                searchStatistics);
 
-            if (solutionFound.found) {
-                Collections.reverse(optimalPath);
-                return optimalPath;
+            if (result == Result.FOUND) {
+                Collections.reverse(path);
+                return path;
             }
 
-            if (previousVisitedSize == visited.size()) {
+            if (result == Result.FAIL) {
                 return List.of();
             }
-            
-            previousVisitedSize = visited.size();
-            visited.clear();
         }
     }
 
-    private static void depthLimitedSearch(
+    private static Result depthLimitedSearch(
             Cell cell, 
             Cell target,
             int depth,
-            SolutionFound solutionFound,
-            List<Cell> tentativePath,
-            List<Cell> optimalPath,
-            Set<Cell> visited,
+            List<Cell> path,
+            Set<Cell> onPath,
             GridModel model,
             GridCellNeighbourIterable iterable,
             PathfindingSettings pathfindingSettings,
             SearchState searchState,
             SearchStatistics searchStatistics) {
 
-        if (solutionFound.found) {
-            return;
+        if (cell.equals(target)) {
+            path.add(target);
+            return Result.FOUND;
         }
 
-        if (depth == 0 && cell.equals(target)) {
-            solutionFound.found = true;
-            optimalPath.addAll(tentativePath);
-            optimalPath.add(target);
-            return;
+        if (depth == 0) {
+            return Result.CUTOFF;
         }
 
-        if (visited.contains(cell)) {
-            return;
-        }
-        
-        tentativePath.add(cell);
-        visited.add(cell);
-        
-        if (!cell.getCellType().equals(CellType.SOURCE) &&
-            !cell.getCellType().equals(CellType.TARGET)) {
-            model.setCellType(cell, CellType.VISITED);
+        if (!onPath.add(cell)) {
+            return Result.FAIL;
         }
+
+        boolean anyCutoff = false;
+        iterable.setStartingCell(cell);
+        searchStatistics.incrementTraced();
 
-        if (depth > 0) {
-            iterable.setStartingCell(cell);
+        for (Cell child : iterable) {
+            if (onPath.contains(child)) {
+                continue;
+            }
 
-            for (Cell child : iterable) {
-                if (visited.contains(child)) {
-                    continue;
-                }
-                
-                if (!child.getCellType().equals(CellType.SOURCE)) {
-                    model.setCellType(child, CellType.TRACED);
-                }
-                
-                searchStatistics.incrementTraced();
+            if (searchState.haltRequested()) {
+                return Result.FAIL;
+            }
+
+            while (searchState.pauseRequested()) {
                 searchSleep(pathfindingSettings);
-                
-                depthLimitedSearch(child, 
-                                   target,
-                                   depth - 1,
-                                   solutionFound, 
-                                   tentativePath,
-                                   optimalPath, 
-                                   visited, 
-                                   model,
-                                   iterable, 
-                                   pathfindingSettings,
-                                   searchState, 
-                                   searchStatistics);
-                
-                if (!child.getCellType().equals(CellType.SOURCE)) {
-                    model.setCellType(child, CellType.FREE);
-                }
-                
-                if (solutionFound.found) {
-                    return;
+
+                if (searchState.haltRequested()) {
+                    return Result.FAIL;
                 }
             }
+            
+            Result result = 
+                    depthLimitedSearch(child,
+                                       target, 
+                                       depth - 1, 
+                                       path, 
+                                       onPath,
+                                       model,
+                                       iterable, 
+                                       pathfindingSettings, 
+                                       searchState, 
+                                       searchStatistics);
+            
+            if (result == Result.FOUND) {
+                path.add(cell);
+                onPath.remove(cell);
+                return Result.FOUND;
+            } else if (result == Result.CUTOFF) {
+                anyCutoff = true;
+            }
         }
 
-        tentativePath.removeLast();
-    }
-    
-    private static final class SolutionFound {
-        boolean found = false;
-    }
-    
-    private static final class Path {
-        List<Cell> path = new ArrayList<>();
+        onPath.remove(cell);
+        return anyCutoff ? Result.CUTOFF : Result.FAIL;
     }
 }

target/classes/io/github/coderodde/pathfinding/app/SettingsPane.class

@@ -1,7 +1,6 @@
 io\github\coderodde\pathfinding\finders\BidirectionalBeamSearchFinder.class
 io\github\coderodde\pathfinding\heuristics\ChebyshevHeuristicFunction.class
 io\github\coderodde\pathfinding\finders\Finder.class
-io\github\coderodde\pathfinding\finders\IDDFSFinder$SolutionFound.class
 io\github\coderodde\pathfinding\finders\IDAStarFinder.class
 io\github\coderodde\pathfinding\heuristics\ZeroHeuristicFunction.class
 io\github\coderodde\pathfinding\app\Configuration.class
@@ -28,7 +27,6 @@ io\github\coderodde\pathfinding\app\SettingsPane$1.class
 io\github\coderodde\pathfinding\finders\BeamSearchFinder.class
 io\github\coderodde\pathfinding\logic\SearchState.class
 io\github\coderodde\pathfinding\logic\SearchState$CurrentState.class
-io\github\coderodde\pathfinding\finders\IDDFSFinder$Path.class
 io\github\coderodde\pathfinding\finders\BidirectionalBestFirstSearchFinder.class
 io\github\coderodde\pathfinding\finders\HeapNode.class
 io\github\coderodde\pathfinding\view\GridView.class
@@ -40,6 +38,7 @@ io\github\coderodde\pathfinding\finders\IDDFSFinder.class
 io\github\coderodde\pathfinding\model\GridModel$1.class
 io\github\coderodde\pathfinding\finders\AStarFinder.class
 io\github\coderodde\pathfinding\finders\DijkstraFinder.class
+io\github\coderodde\pathfinding\finders\IDDFSFinder$Result.class
 io\github\coderodde\pathfinding\finders\NBAStarFinder$TouchCell.class
 io\github\coderodde\pathfinding\finders\IDAStarFinder$SolutionFound.class
 io\github\coderodde\pathfinding\controller\GridController.class