Search gets expensive when every path looks equally possible. That is the real problem. A heuristic gives the algorithm a sense of direction. It does not solve the problem by itself. But it tells the search what looks worth exploring first. A heuristic function estimates how close a state is to the goal. In search algorithms, that estimate becomes a decision signal. Instead of exploring blindly, the algorithm can prioritize promising states. That is why heuristics matter. They turn search from “try everything” into “try the most promising thing first.” A simple search decision looks like this: Current State → Heuristic Estimate → Priority → Next State For A*, the structure is: f(n) = g(n) + h(n) Where: g(n) = cost from the start to the current node h(n) = estimated cost from the current node to the goal f(n) = total estimated cost The heuristic is h(n). It is the part that points the search toward the goal. At a high level, heuristic search works like this: start from the initial state while there are states to explore: estimate how promising each state is choose the state with the best score if it is the goal: return the solution expand the next states return failure This is why heuristic quality matters in implementation. A weak heuristic barely improves search. A bad heuristic can guide the algorithm in the wrong direction. A good heuristic reduces wasted exploration. Imagine pathfinding on a grid. You want to move from Start to Goal. If movement is only up, down, left, and right, Manhattan distance often fits well. It estimates distance like this: Manhattan distance = |x1 - x2| + |y1 - y2| If movement can happen freely in straight lines, Euclidean distance may fit better. Euclidean distance = straight-line distance The point is not that one is always better. The point is that the heuristic should match the structure of the problem. Blind search has no sense of direction. It explores based only on the search rule. For example, BFS expands level by level. DFS goes deep first. Heuristic search adds an estimate. Blind search: explores without goal guidance can waste time on irrelevant paths works well for small or simple state spaces Heuristic search: uses a goal-directed signal prioritizes promising states becomes much more useful when the state space is large This is why heuristics are so important in AI search. They do not just make the search faster. They change the order of exploration. Greedy Search and A* both use heuristics. But they use them differently. Greedy Search uses only: h(n) A* uses: f(n) = g(n) + h(n) Greedy Search asks: “Which state looks closest to the goal?” A* asks: “Which state has the best total estimated path cost?” That difference matters. Greedy Search can be fast. But it can ignore the cost already paid. A* is more balanced because it combines actual cost with estimated future cost. A heuristic is admissible if it never overestimates the true cost to the goal. In simple terms: h(n) <= true remaining cost This condition matters because A* depends on the heuristic. If the heuristic overestimates too much, A* may skip the optimal path. Admissibility keeps the estimate safe. It helps A* preserve the optimality guarantee. Consistency is also called monotonicity. It means the heuristic behaves smoothly as the search moves from one node to another. Conceptually: The estimated cost should not suddenly contradict the cost of moving between nodes. Consistency helps A* behave cleanly during expansion. In many implementations, it also avoids reopening already processed nodes. So the difference is: Admissibility protects optimality. Consistency keeps the search process stable. They are related, but not identical. If heuristics feel abstract, learn them in this order: Heuristic Function Manhattan Distance vs Euclidean Distance Admissibility Consistency Greedy Search A* Algorithm This order works because you first understand the estimate. Then you see concrete distance examples. Then you understand the conditions that make heuristic search reliable. A heuristic is a search shortcut. But not a random shortcut. It is a structured estimate that tells the algorithm what looks promising. The shortest version is: Heuristic = estimated remaining cost In A*: f(n) = g(n) + h(n) The better h(n) matches the problem, the less unnecessary search you do. If you remember one idea, remember this: A heuristic makes search smarter by giving it direction before the full answer is known. When designing a heuristic, do you prefer a simple safe estimate like Manhattan distance, or a more aggressive estimate that may guide the search faster? Originally published at zeromathai.com. https://zeromathai.com/en/heuristic-function-ai-search-hub-en/ GitHub Resources https://github.com/zeromathai/zeromathai-ai