AI search does not start with an algorithm. It starts with structure. Before BFS, DFS, A*, or heuristics can work, the problem must first become something searchable. That is where graphs come in. Many AI problems can be represented as graphs. A graph gives the problem a structure: states become nodes relationships become edges possible moves become paths goals become target nodes Once the problem has this form, search algorithms can operate on it. Without structure, search is just guessing. With structure, search becomes systematic. The basic transformation looks like this: Problem → Graph → Search Order → Distance / Heuristic → Decision In simpler terms: Real-world problem → searchable structure → algorithmic choice That is why graph theory matters. It is the bridge between an abstract problem and a concrete search algorithm. At a high level, graph-based search works like this: represent the problem as nodes and edges choose a data structure for exploration visit nodes in a controlled order measure progress toward the goal use heuristics if the search space is large return a path, decision, or failure This is why graph structure is not just theory. It directly affects implementation. The graph decides what can be visited. The data structure decides the order. The heuristic decides what looks promising. Imagine a map navigation problem. Cities can be nodes. Roads can be edges. The destination is the goal. Now the problem becomes searchable. BFS can explore nearby cities first. DFS can follow one route deeply. A* can use distance estimates to prioritize promising routes. Same problem. Different search behavior. The difference comes from how the graph is explored. Not all graphs mean the same thing. Direction changes the meaning of the structure. An undirected graph says: A is connected to B. So movement or relationship can go both ways. A directed graph says: A points to B. So the relationship has direction. This matters in AI because direction often represents dependency, order, or allowed movement. For example: road networks may be directed if some roads are one-way dependency graphs are directed task scheduling often uses direction causal-style structures often use direction A DAG is a Directed Acyclic Graph. That means: edges have direction cycles are not allowed This makes DAGs useful when order matters. For example: Task A must happen before Task B. An undirected graph is different. It represents mutual connection without direction. So the key comparison is: DAG = ordered dependency structure Undirected graph = mutual relationship structure If you mix these up, the meaning of the graph changes. Once the graph exists, search needs an exploration rule. Two basic data structures explain a lot: Queue: first in, first out used by BFS explores level by level Stack: last in, first out used by DFS follows one path deeply This is why BFS and DFS behave so differently. They are not mysterious. They are mostly different because they use different exploration orders. BFS expands the nearest nodes first. DFS follows one branch as deep as possible. BFS: good when shortest path in an unweighted graph matters can use more memory explores broadly DFS: good when memory is limited can go deep quickly may explore a poor branch for too long So the choice is not “which is better?” The better question is: What kind of exploration does the problem need? Basic graph search follows structure. Heuristic search adds judgment. To make better decisions, the algorithm needs a way to estimate closeness. That is where distance metrics help. For grid-like problems: Manhattan distance works well when movement is horizontal and vertical. Euclidean distance works well when straight-line distance matters. Then a heuristic function uses that idea to estimate remaining cost. A simple pathfinding view: f(n) = g(n) + h(n) Where: g(n) = cost so far h(n) = estimated cost to the goal f(n) = total estimated cost This is the core of A*. A heuristic can make search much faster. But it must be designed carefully. If the heuristic is too weak, search behaves almost like brute force. If the heuristic is too aggressive, it may guide the search incorrectly. For A*, two conditions often matter: Admissibility: The heuristic should not overestimate the true cost. Consistency: The heuristic should stay stable as the search moves between nodes. These conditions help heuristic search remain reliable. If graph-based search feels scattered, learn it in this order: Graph Theory Directed and Undirected Graphs DAG Queue Stack BFS DFS Distance Metrics Heuristic Function A* Algorithm This order works because you first understand the structure. Then you understand exploration order. Then you understand heuristic guidance. AI search is not just about algorithms. It is about turning a problem into a structure that algorithms can operate on. The shortest version is: Graph structure + exploration order + heuristic guidance = search behavior Graphs define the possible world. Queues and stacks define how that world is explored. Distance metrics and heuristics define what looks promising. If you remember one idea, remember this: Before you choose BFS, DFS, or A*, first ask how the problem should be represented as a graph. When solving graph search problems, do you usually start by choosing the algorithm first, or by modeling the states and edges first? Originally published at zeromathai.com. https://zeromathai.com/en/graph-structure-search-hub-en/ GitHub Resources https://github.com/zeromathai/zeromathai-ai