Pith. sign in

REVIEW 3 major objections 4 minor 31 references

GridRoute: A Benchmark for LLM-Based Route Planning with Cardinal Movement in Grid Environments

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Algorithm-guided prompting reproduces the performance gains of classical pathfinders by describing them in the prompt.

desk verdict Worth a look for the benchmark, but the headline claim about AoP's uniform gains is not supported by the paper's own tables. read the letter →

arxiv 2505.24306 v2 pith:635DZ35L submitted 2025-05-30 cs.AI

Kechen Li , Yaotian Tao , Ximing Wen , Quanwei Sun , Zifei Gong , Chang Xu , Xizhe Zhang , Tianbo Ji This is my paper
classification cs.AI
keywords gridpathplanninglargelanguagemodelsalgorithm-guidedpromptingAlgorithmofpathfindingbenchmarkchain-of-thoughtA*searchDijkstra
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper introduces GridRoute, a benchmark that asks large language models to plan grid paths with cardinal moves, and an Algorithm of Planning (AoP) prompting strategy that embeds the logic of A*, Dijkstra, or DFS directly into the instruction text. The central claim is that AoP significantly improves route-planning correctness and optimality compared with a vanilla prompt across all tested model sizes, with the largest gains on bigger or more obstacle-dense maps. A sympathetic reader would care because it suggests that LLMs can be turned into more dependable path planners by describing a classical algorithm inside the prompt, rather than relying on the model's own reasoning alone. The paper also reports that AoP performs comparably to chain-of-thought prompting and that adding example trajectories to AoP can help further.

What carries the argument

The central object is the Algorithm of Planning (AoP) prompt, a template that spells out the reasoning principles of a classical pathfinding algorithm—move ordering and backtracking for DFS, Manhattan heuristic and open-set selection for A*, priority-queue distance updates and parent reconstruction for Dijkstra—inside the instruction. The prompt's job is to get the LLM to simulate the algorithm's search behavior while generating a coordinate path, and the benchmark measures the result with compliance, feasibility, optimality, geometric-mean length ratio, squared length error, and response time.

What would settle it

Repeat the GridRoute evaluation with multiple independent samples per instance (for example, five runs at temperature 0.7) and compute confidence intervals for FR and OR; if the AoP-Vanilla gap shrinks to within noise on these replicates, the headline improvement claim collapses.

Watch

Extended reading notes

Core claim

The paper claims that algorithm-guided prompting (AoP) significantly boosts LLM route-planning performance relative to vanilla prompting, and that the boost is most pronounced in larger or more complex grid environments. Among the three algorithm variants, AoP-Dijkstra and AoP-A* consistently improve feasibility and optimality, while AoP-DFS lags; chain-of-thought remains the most stable strategy across model sizes. Results across Qwen2.5-7B/32B/72B, LLaMA3.1-70B, DeepSeek-V3, and GPT-4 Turbo show that larger models do better under independent prompting but that algorithmic guidance helps at every scale, and that model-size gains plateau beyond a certain size while map size is the dominant difficulty factor.

Load-bearing premise

A single LLM response per test case is enough to rank prompting strategies, so differences between AoP and Vanilla are treated as real even though the models' outputs can vary between runs.

Editorial extensions

If this is right

  • Embedding a description of A* or Dijkstra into a prompt can make LLM path planning more reliable than plain instructions, especially on 20x20 and 30x30 maps.
  • AoP-Dijkstra matches chain-of-thought on stability and can outperform it on small models.
  • Adding direct example trajectories (Algo-Direct) to AoP-Dijkstra further improves most metrics, while reasoning-heavy examples (Algo-Reasoning) can improve length quality at the cost of feasibility.
  • Map size, not model size, is the dominant driver of difficulty; gains from scaling models diminish on larger grids.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The reported gains might reflect the prompt forcing a more structured output format rather than genuine algorithm simulation; a probe that varies only formatting constraints could separate the two effects.
  • If AoP works by eliciting step-by-step search, it may combine with verification loops that check each generated step against the grid, turning the LLM into a heuristic generator inside a classical planner rather than the planner itself.
  • The benchmark's single-sample protocol leaves open the possibility that temperature and sampling noise account for part of the gaps; re-running with multiple samples would tell whether the ranking is stable.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper introduces GridRoute, a benchmark for evaluating LLMs on route planning in grid environments with cardinal movement, and proposes Algorithm of Planning (AoP) prompting, which embeds classical algorithms (DFS, A*, Dijkstra) into prompts. It evaluates six models (Qwen2.5-7B/32B/72B, LLaMA3.1-70B, DeepSeek-V3, GPT-4 Turbo) on three map sizes, reporting compliance, feasibility, optimality, geometric mean, MSE, and runtime. The central claim is that AoP significantly improves route-planning performance over Vanilla prompts across all model sizes, especially in larger or more complex environments, and is comparable to or better than CoT. The paper also studies few-shot variants (Algo-Direct, Algo-Reasoning) and analyzes failure types.

Significance. If the reported results are reliable, GridRoute would be a useful, open-source benchmark for studying how LLMs can exploit classical algorithm guidance, and the AoP prompt family would be a practical contribution to prompt engineering for planning tasks. The paper's strengths include a clear task design, a detailed error taxonomy, a multi-model and multi-scale evaluation, and an open-source implementation. However, the quantitative evidence for the headline claim is currently undermined by internal inconsistencies in the results tables and the absence of uncertainty quantification; as printed, the abstract's 'significantly boosts performance across all model sizes' is not supported by the paper's own data. The benchmark machinery itself is plausible, and the issues appear correctable with additional experiments and table verification.

major comments (3)
  1. [Tables 9-10] The results tables contain entries that are impossible on the definitions of Section 3.2. In Table 10, qwen2.5-32b-Instruct under AoP-Dijkstra at size 20 is listed with CR=100 but FR=0.51 and OR=0.45, and qwen2.5-72b-Instruct under AoP-Dijkstra at size 30 has CR=1 while FR=OR=66; ChatGPT-4 under AoP-DFS is listed with CR=FR=OR=3/1/1 across sizes. Since CR, FR, and OR are defined as percentages of Ncase, these values cannot all be correct. Table 9 also shows byte-identical CoT rows for qwen2.5-7b-instruct and qwen2.5-72b-instruct across all three map sizes, which is implausible for independent runs. These entries are not cosmetic: they are part of the very comparisons that Remark 1 is based on. The tables need to be corrected and re-verified before the headline claim can be assessed.
  2. [Sections 4.1-4.2, 5, Tables 9-11] The paper reports no number of test cases per condition, no sampling temperature, and no repeated sampling, and all comparisons are point estimates without error bars or significance tests. Section 3.1 says 'five pairs' of origin-destination points are sampled per environment but does not state how many environments are generated, so Ncase is not fixed; if Ncase is small, each FR/OR entry is a coarse multiple and differences of a few percent may be within sampling noise. The abstract's 'significantly boosts' and Remark 1 therefore need either repeated runs with confidence intervals or statistical tests, or a clear statement that deterministic decoding was used and that Ncase is large enough to make the differences meaningful. As it stands, the evidential basis for the central claim is not established.
  3. [Abstract, Remark 1, Table 10] The claim that AoP 'significantly boosts performance across all model sizes' is contradicted by the paper's own results for several model-prompt combinations. In Table 10, ChatGPT-4 under AoP-A* has lower FR and OR than Vanilla at every map size (e.g., FR 65 vs 76 at size 10, 48 vs 61 at size 20, 41 vs 62 at size 30), and ChatGPT-4 under AoP-DFS essentially collapses (CR=3, 1, 1). Similarly, qwen2.5-32b under AoP-Dijkstra does not improve over Vanilla at size 20 if the printed values are interpreted as percentages. The statement in Remark 1 must either be restricted to the specific models and AoP variants for which the data actually show consistent improvement, or the corrected tables must be provided.
minor comments (4)
  1. [Abstract, Section 4.2] The abstract calls the proposed method 'Algorithm of Thought (AoT)', while the rest of the paper uses 'Algorithm of Planning (AoP)'; the terminology should be made consistent.
  2. [Section 3.1] The phrase 'constrained diagonal Dijkstra algorithm' is confusing for a grid with cardinal-only movement; please define this algorithm precisely or rename it to avoid implying diagonal moves are used for the ground-truth paths.
  3. [Figure 1, Figure 2] Figure 1's caption contains 'Struture' and Figure 2's caption contains 'Path though obstacles'; these typos should be corrected.
  4. [Table 9 and Figures 3-4] The 'Few-shot Learning' label in Table 9 is split across rows, and the caption promises boldfaced top performance per group but no boldface appears in the displayed table; the legend in Figures 3 and 4 also uses 'AoP-A star' instead of 'AoP-A*' and includes an 'Algo-Reasoning (Invalid)' category that is not defined in Section 4.2.

Circularity Check

0 steps flagged · score 2.0 of 10

No significant circularity: the central claims are empirical comparisons measured against an identical Dijkstra ground truth, with no fitted parameters, no load-bearing self-citations, and no derivation chain whose output equals its input by construction.

full rationale

The paper's central claims (abstract; Remark 1; Section 5 RQ1) are empirical: AoP prompts are measured against Vanilla, CoT, and FewShot prompts on the same six metrics. The only element that looks potentially circular is that the benchmark defines optimality via a Dijkstra ground truth (Section 3.1: 'we employ a constrained diagonal Dijkstra algorithm to compute the shortest paths for all task instances') and OR/GM/MSE compare against it (Section 3.2: 'whether a feasible LLM-generated route is optimal compared to the Dijkstra ground truth'), while the AoP-Dijkstra prompt embeds Dijkstra logic (Section 4.2.2: 'embedding Dijkstra's core logic – greedy distance minimization, neighbor evaluation, and path optimality'). This is not construction-equivalence: if it were, AoP-Dijkstra OR would be near 100% for every model, but Table 10 reports OR values of 55/31/20 for Qwen2.5-7B at sizes 10/20/30 and 75/61/60 for Qwen2.5-72B, so the measured outcomes are not forced by the metric definition. Every prompt is evaluated against the same ground truth, so the Vanilla-to-AoP comparison is a fair empirical contrast and the improvement claim is falsifiable by the same tables. No parameter is fitted and renamed as a prediction, and there is no first-principles derivation whose output is identical to its input. Self-citations (Li et al. 2025, Wen 2025, Wang et al. 2023) appear only in related-work context (Section 2.2) to support generic statements about LLM capabilities; they are not load-bearing for GridRoute's results, and no uniqueness theorem or algorithm ansatz is imported from the authors' prior work. The skeptic concerns about missing repeated sampling, absent significance testing, and internally inconsistent table entries (e.g., Table 10 showing CR=1 with FR=0.51/OR=0.45 for qwen2.5-32b AoP-Dijkstra at size 20, and near-duplicate CoT rows in Table 9) are statistical-validity and data-integrity issues, which are correctness risks rather than circularity. The prompts, metrics, and code are open-sourced, so the central empirical claim is independently checkable.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

The benchmark introduces no fitted mathematical parameters or invented entities. Its conclusions rest on hand-chosen map configurations, a minimum-distance threshold, a small number of start-goal pairs, and standard correctness of classical pathfinding algorithms.

free parameters (4)
  • map configuration {N,n,s} = {10,2,3}, {20,3,4}, {30,4,5}
    Hand-selected difficulty levels; all reported results are conditional on these three configurations.
  • minimum start-goal distance threshold = 30% of grid diagonal
    Chosen to ensure meaningful planning; affects task difficulty and may not generalize.
  • number of start-goal pairs per map = 5
    Randomly sampled pairs per map; no total number of environments is stated, so statistical power is unclear.
  • few-shot example paths = 2 hand-written examples
    Used in FewShot-Base, Algo-Direct, and Algo-Reasoning; the choice of examples can affect performance and is not swept.
assumptions (3)
  • standard math Classical pathfinding algorithms such as A*, Dijkstra, and BFS produce correct shortest paths under 4-direction movement on unweighted grids.
    The benchmark relies on BFS connectivity checks and a Dijkstra reference in Section 3.1.
  • domain assumption LLM outputs are syntactically parseable coordinate lists, and compliance metrics faithfully measure planning ability.
    Metrics in Section 3.2 parse model outputs as routes; format failures may reflect instruction following rather than planning.
  • domain assumption The three selected map configurations are representative of grid pathfinding difficulty.
    Only three square obstacle configurations with five O/D pairs per map are used in Tables 9-11.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GridRoute: A Benchmark for LLM-Based Route Planning with Cardinal Movement in Grid Environments." pith.science (2026). https://pith.science/paper/635DZ35L

@misc{pith2026250524306,
  author       = {Pith},
  title        = {Pith review of: GridRoute: A Benchmark for LLM-Based Route Planning with Cardinal Movement in Grid Environments},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/635DZ35L}},
  note         = {Machine review of arXiv:2505.24306}
}
read the original abstract

Recent advancements in Large Language Models (LLMs) have demonstrated their potential in planning and reasoning tasks, offering a flexible alternative to classical pathfinding algorithms. However, most existing studies focus on LLMs' independent reasoning capabilities and overlook the potential synergy between LLMs and traditional algorithms. To fill this gap, we propose a comprehensive evaluation benchmark GridRoute to assess how LLMs can take advantage of traditional algorithms. We also propose a novel hybrid prompting technique called Algorithm of Thought (AoT), which introduces traditional algorithms' guidance into prompting. Our benchmark evaluates six LLMs ranging from 7B to 72B parameters across various map sizes, assessing their performance in correctness, optimality, and efficiency in grid environments with varying sizes. Our results show that AoT significantly boosts performance across all model sizes, particularly in larger or more complex environments, suggesting a promising approach to addressing path planning challenges. Our code is open-sourced at https://github.com/LinChance/GridRoute.

Figures

Figures reproduced from arXiv: 2505.24306 by the authors.

Figure 1
Figure 1. Struture of GridRoute ally efficient, and particularly suited for real-time or embedded applications. 3 GridRoute Benchmark This section introduces the design of the GridRoute benchmark, including data generation, evaluation metrics, and error analysis. We first describe how the task environments are constructed and pre￾sented to LLMs, followed by the metrics used to assess performance. Finally, we analyze common fa… view at source ↗
Figure 2
Figure 2. Error distribution of LLMs across three map [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Average evaluation results across three map sizes for each metric using Vanilla and AoP prompts (q-7B: [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Average evaluation results across three map sizes for each metric using CoT, FewShot-Base, and AoP [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Average evaluation results across three map sizes for each metric using FewShot-Base and Algo-Shot [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Performance evaluation of Qwen2.5-32B using three prompt strategies (CoT, AoP-A*, Algorithm-Direct) [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Deepseek-V3 performance CR OR FR GM MSE RT Vanilla 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.10 1.15 1.20 0 10 20 30 40 50 0 5 10 15 20 CR OR FR GM MSE RT CoT 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.10…
Figure 8
Figure 8. Figure 8: GPT4-Turbo performance 17 [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]
Figure 9
Figure 9. Figure 9: LLaMA3.1-70B performance CR OR FR GM MSE RT Vanilla 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.10 1.15 1.20 0 10 20 30 40 50 0 5 10 15 20 CR OR FR GM MSE RT CoT 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.1…
Figure 10
Figure 10. Figure 10: Qwen2.5-7B performance 18 [PITH_FULL_IMAGE:figures/full_fig_p018_10.png]
Figure 11
Figure 11. Figure 11: Qwen2.5-32B performance CR OR FR GM MSE RT Vanilla 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.10 1.15 1.20 0 10 20 30 40 50 0 5 10 15 20 CR OR FR GM MSE RT CoT 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 20% 40% 60% 80% 100% 1.00 1.05 1.1…
Figure 12
Figure 12. Figure 12: Qwen2.5-72B performance 19 [PITH_FULL_IMAGE:figures/full_fig_p019_12.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

31 extracted references · 30 canonical work pages

  1. [1]

    Every point must differ by exactly 1 in either x or y direction from the previous point (no diagonal moves allowed)

    work page

  2. [2]

    The output should be in the format: [(x1, y1), (x2, y2), (x3, y3), ...]

    work page

  3. [3]

    Return only the path without any additional explanation

    If a valid path cannot be created without touching an obstacle, return an empty path []. Return only the path without any additional explanation. Table 1: Vanilla prompt Here are the obstacle coordinates in the grid:{obstacles}" You need to plan a path from the starting point ({start_x}, {start_y}) to the ending point ({end_x, end_y) while avoiding the ob...

    work page

  4. [4]

    Return the final path in this format: [(x1, y1), (x2, y2), (x3, y3), ...]

    If there is no valid path, return an empty path []. Return the final path in this format: [(x1, y1), (x2, y2), (x3, y3), ...]. If there are any errors or no valid paths, return []. Make sure to provide only the path in your response without any extra explanations. Table 2: CoT prompt Plan the shortest path from the starting point ({start_x}, {start_y}) to...

    work page

  5. [5]

    Verify that the starting point {(start_x},{start_y)} and ending point ({end_x, {end_y}) are not obstacles

    work page

  6. [6]

    A move is valid if: - It differs by exactly 1 in either the x or y direction from the previous point

    List all valid moves for a point in the grid. A move is valid if: - It differs by exactly 1 in either the x or y direction from the previous point. - It does not overlap with any obstacle

    work page

  7. [7]

    Starting from ({start_x}, {start_y}), iteratively choose the next valid move to build a path to ({end_x}, {end_y})

    work page

  8. [11]

    Define valid moves: -Up: (x, y+ 1) -Down: (x, y− 1) -Right: (x + 1, y) -Left: (x − 1, y)

    work page

Show all 31 references
  1. [12]

    - At each step, evaluate valid moves and select the one that minimizes the distance to ({end_x}, {end_y})

    Build the path: - Start at ({start_x}, {start_y}). - At each step, evaluate valid moves and select the one that minimizes the distance to ({end_x}, {end_y})

  2. [13]

    If no valid moves are available, return an empty path []

  3. [14]

    Output the result in this format: [(x1, y1), (x2, y2), ..., (xn, yn)]. Example 1: Start: (3, 7), End: (4, 3), Obstacles: [((1, 2), (3, 4)), ((2, 5), (4, 6))] Path: [(3, 7), (4, 7), (5, 7), (5, 6), (5, 5), (5, 4), (5, 3), (4, 3)] Example 2: Start: (2, 4), End: (7, 5), Obstacles...

  4. [17]

    Define valid moves (same priority order): - Up: (x, y+1) - Down: (x, y-1) - Right: (x+1, y) - Left: (x-1, y) - All moves must stay within the grid bounds and avoid obstacle cells

  5. [18]

    Use Depth-First Search (DFS) algorithm: - Initialize a stack with the start cell and its path [(start_x, start_y)] - Create a visited set to track explored cells - While stack is not empty: - Pop the last cell and its path from the stack - If current cell is the endpoint, retu...

  6. [19]

    - First valid path found using DFS should be returned

    Termination conditions: - If stack becomes empty before reaching endpoint, return empty path []. - First valid path found using DFS should be returned

  7. [20]

    Return only the path as output, without additional explanations

    Output the result in this format: [(x1, y1), (x2, y2), ..., (xn, yn)]. Return only the path as output, without additional explanations. Table 4: AoP-DFS prompt 11 Plan the shortest path from the starting point ({start_x}, {start_y}) to the endpoint ({end_x}, {end_y}) while avo...

  8. [24]

    - Initialize f_score (g_score + heuristic) for all cells to infinity, except the start cell which is heuristic(start, end)

    Use A* algorithm: - Initialize g_score (cost from start) for all cells to infinity, except the start cell which is 0. - Initialize f_score (g_score + heuristic) for all cells to infinity, except the start cell which is heuristic(start, end). - Use a priority queue to repeatedl...

  9. [25]

    - Trace back from the endpoint to the starting point using the recorded parent cells to reconstruct the shortest path

    Construct the path: - Start at (start_x, start_y). - Trace back from the endpoint to the starting point using the recorded parent cells to reconstruct the shortest path. - If no valid moves are available, return an empty path []

  10. [26]

    Return only the path as output, without additional explanations

    Output the result in this format: [(x1, y1), (x2, y2), ..., (xn, yn)]. Return only the path as output, without additional explanations. Table 5: AoP-A* prompt 12 Plan the shortest path from the starting point ({start_x}, {start_y}) to the endpoint ({end_x}, {end_y}) while avoi...

  11. [32]

    Return only the path as output, without additional explanations

    Output the result in this format: [(x1, y1), (x2, y2), ..., (xn, yn)]. Return only the path as output, without additional explanations. Table 6: AoP-Dijkstra prompt 13 A.3 AoP with Example (Algo-Shot) Prompt Plan the shortest path from the starting point ({start_x}, {start_y})...

  12. [33]

    Analyze the grid to identify the start, end, and rectangular obstacle locations

  13. [34]

    A grid cell (x, y) is an obstacle if x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2

    Each rectangle is defined by its top-left corner (x1, y1) and bottom-right corner (x2, y2). A grid cell (x, y) is an obstacle if x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2

  14. [35]

    Define valid moves: - Up: (x, y+1) - Down: (x, y-1) - Right: (x+1, y) - Left: (x-1, y) - All moves must stay within the grid bounds and avoid obstacle cells

  15. [36]

    - Use a priority queue to repeatedly select the grid cell with the smallest tentative distance

    Use Dijkstra’s algorithm: - Assign an initial distance of infinity to all grid cells except the starting point, which should have a distance of 0. - Use a priority queue to repeatedly select the grid cell with the smallest tentative distance. - For each selected cell, evaluate...

  16. [37]

    - Trace back from the endpoint to the starting point using the recorded parent cells to reconstruct the shortest path

    Construct the path:" - Start at ({start_x}, {start_y}). - Trace back from the endpoint to the starting point using the recorded parent cells to reconstruct the shortest path. - If no valid moves are available, return an empty path []

  17. [38]

    Output the result in this format: [(x1, y1), (x2, y2), ..., (xn, yn)]. Example 1: Start: (3, 7), End: (4, 3), Obstacles: [((1, 2), (3, 4)), ((2, 5), (4, 6))] Path: [(3, 7), (4, 7), (5, 7), (5, 6), (5, 5), (5, 4), (5, 3), (4, 3)] Example 2: Start: (2, 4), End: (7, 5), Obstacles...

  18. [39]

    Verify the starting point ({start_x}, {start_y}) and ending point ({end_x}, {end_y}) are not obstacles

  19. [40]

    - For all other points, initialize the cost as infinity (∞)

    Define the cost of reaching a point in the grid: - Start by assigning a cost of 0 to the starting point ({start_x}, {start_y}). - For all other points, initialize the cost as infinity (∞)

  20. [41]

    - At each step, select the point with the lowest current cost

    Use a priority queue to iteratively explore points in the grid: - Begin with the starting point ({start_x}, {start_y}) in the queue. - At each step, select the point with the lowest current cost. - For each valid move (up, down, left, right): a. If moving to a neighboring poin...

  21. [42]

    - If no valid path exists, return an empty path []

    Repeat this process until reaching the ending point ({end_x}, {end_y}) or exhausting all valid points in the queue: - If the ending point is reached, reconstruct the path by tracing back from the endpoint to the start using the cost values. - If no valid path exists, return an...

  22. [43]

    If there are any errors or no valid paths, return []

    Return the final path in this format: [(x1, y1), (x2, y2), (x3, y3), ...]. If there are any errors or no valid paths, return []. Example: Start: (3, 7), End: (4, 3), Obstacles: [((1, 2), (3, 4)), ((2, 5), (4, 6))], grid: 10 Evaluate valid neighbors in given map: - Starting at ...

  23. [2023]

    arXiv preprint arXiv:2304.11477

    Llm+ p: Empowering large language mod- els with optimal planning proficiency. arXiv preprint arXiv:2304.11477. Silin Meng. 2025. Llm-a*: Large language model en- hanced incremental heuristic search on path planning. Master’s thesis, University of California, Los Ange- les. Ope...

    2025 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.