Đồ thị (Graph)

from collections import defaultdict
 
graph = defaultdict(list)
graph[0].append(1)  # 0 -> 1
graph[0].append(2)  # 0 -> 2
graph[1].append(2)  # 1 -> 2
 
# Hoặc dùng dict
graph = {
    0: [1, 2],
    1: [2],
    2: [0, 3],
    3: [3]
}

val graph = mutableMapOf<Int, MutableList<Int>>()
graph.getOrPut(0) { mutableListOf() }.add(1)
graph.getOrPut(0) { mutableListOf() }.add(2)
graph.getOrPut(1) { mutableListOf() }.add(2)
 
// Hoặc
val graph = mapOf(
    0 to listOf(1, 2),
    1 to listOf(2),
    2 to listOf(0, 3)
)

Map<int, List<int>> graph = {
  0: [1, 2],
  1: [2],
  2: [0, 3],
  3: [3]
};
 
// Thêm cạnh
graph.putIfAbsent(4, () => []);
graph[4]!.add(5);

var graph: [Int: [Int]] = [
    0: [1, 2],
    1: [2],
    2: [0, 3],
    3: [3]
]
 
// Thêm cạnh
graph[4, default: []].append(5)

Map<Integer, List<Integer>> graph = new HashMap<>();
graph.computeIfAbsent(0, k -> new ArrayList<>()).add(1);
graph.computeIfAbsent(0, k -> new ArrayList<>()).add(2);
 
// Hoặc
graph.put(0, List.of(1, 2));
graph.put(1, List.of(2));

from collections import deque
 
def bfs(graph, start):
    visited = set([start])
    queue = deque([start])
    result = []
    
    while queue:
        node = queue.popleft()
        result.append(node)
        
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    
    return result

fun bfs(graph: Map<Int, List<Int>>, start: Int): List<Int> {
    val visited = mutableSetOf(start)
    val queue = ArrayDeque<Int>()
    queue.addLast(start)
    val result = mutableListOf<Int>()
    
    while (queue.isNotEmpty()) {
        val node = queue.removeFirst()
        result.add(node)
        
        for (neighbor in graph[node] ?: emptyList()) {
            if (neighbor !in visited) {
                visited.add(neighbor)
                queue.addLast(neighbor)
            }
        }
    }
    return result
}

List<int> bfs(Map<int, List<int>> graph, int start) {
  Set<int> visited = {start};
  Queue<int> queue = Queue()..add(start);
  List<int> result = [];
  
  while (queue.isNotEmpty) {
    int node = queue.removeFirst();
    result.add(node);
    
    for (int neighbor in graph[node] ?? []) {
      if (!visited.contains(neighbor)) {
        visited.add(neighbor);
        queue.add(neighbor);
      }
    }
  }
  return result;
}

func bfs(_ graph: [Int: [Int]], _ start: Int) -> [Int] {
    var visited = Set([start])
    var queue = [start]
    var result = [Int]()
    
    while !queue.isEmpty {
        let node = queue.removeFirst()
        result.append(node)
        
        for neighbor in graph[node] ?? [] {
            if !visited.contains(neighbor) {
                visited.insert(neighbor)
                queue.append(neighbor)
            }
        }
    }
    return result
}

List<Integer> bfs(Map<Integer, List<Integer>> graph, int start) {
    Set<Integer> visited = new HashSet<>();
    Queue<Integer> queue = new LinkedList<>();
    List<Integer> result = new ArrayList<>();
    
    visited.add(start);
    queue.offer(start);
    
    while (!queue.isEmpty()) {
        int node = queue.poll();
        result.add(node);
        
        for (int neighbor : graph.getOrDefault(node, List.of())) {
            if (!visited.contains(neighbor)) {
                visited.add(neighbor);
                queue.offer(neighbor);
            }
        }
    }
    return result;
}

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    
    visited.add(start)
    result = [start]
    
    for neighbor in graph.get(start, []):
        if neighbor not in visited:
            result.extend(dfs(graph, neighbor, visited))
    
    return result

fun dfs(graph: Map<Int, List<Int>>, start: Int, visited: MutableSet<Int> = mutableSetOf()): List<Int> {
    visited.add(start)
    val result = mutableListOf(start)
    
    for (neighbor in graph[start] ?: emptyList()) {
        if (neighbor !in visited) {
            result.addAll(dfs(graph, neighbor, visited))
        }
    }
    return result
}

List<int> dfs(Map<int, List<int>> graph, int start, [Set<int>? visited]) {
  visited ??= {};
  visited.add(start);
  List<int> result = [start];
  
  for (int neighbor in graph[start] ?? []) {
    if (!visited.contains(neighbor)) {
      result.addAll(dfs(graph, neighbor, visited));
    }
  }
  return result;
}

func dfs(_ graph: [Int: [Int]], _ start: Int, _ visited: inout Set<Int>) -> [Int] {
    visited.insert(start)
    var result = [start]
    
    for neighbor in graph[start] ?? [] {
        if !visited.contains(neighbor) {
            result.append(contentsOf: dfs(graph, neighbor, &visited))
        }
    }
    return result
}

List<Integer> dfs(Map<Integer, List<Integer>> graph, int start, Set<Integer> visited) {
    visited.add(start);
    List<Integer> result = new ArrayList<>();
    result.add(start);
    
    for (int neighbor : graph.getOrDefault(start, List.of())) {
        if (!visited.contains(neighbor)) {
            result.addAll(dfs(graph, neighbor, visited));
        }
    }
    return result;
}