Graph theory plays a central role in competitive programming because many problems can be modeled as graphs, including those involving networks, paths, connectivity, and relationships between entities. A graph consists of nodes (or vertices) connected by edges, and understanding how to represent and traverse graphs is critical for solving a wide range of problems. The most common graph traversal algorithms are breadth-first search (BFS) and depth-first search (DFS), both of which allow you to explore the nodes of a graph systematically. BFS is typically used to find the shortest path in unweighted graphs or to explore all nodes within a certain distance, while DFS is used for tasks like detecting cycles, finding connected components, or performing topological sorting. Beyond traversal, graph theory includes algorithms for finding the shortest paths between nodes. Dijkstra's algorithm is the most commonly used algorithm for finding the shortest path in a graph with non-negative edge weights, while the Floyd-Warshall algorithm is useful for finding shortest paths between all pairs of nodes in a graph. In competitive programming, graph problems often involve optimizing paths or flows, detecting cycles, or finding the minimum spanning tree of a graph using algorithms like Kruskal's or Prim's. Many problems can also be framed as network flow problems, where the goal is to maximize the flow of some resource through a network. Understanding the fundamentals of graph theory and mastering the key algorithms will give you a significant advantage in solving competitive programming problems, especially those involving networks, paths, and connectivity.