الرسوم البيانية (Graphs)

int[][] graph = {
    {0, 1, 0, 0},
    {1, 0, 1, 1},
    {0, 1, 0, 1},
    {0, 1, 1, 0}
};

import java.util.*;

Map<Integer, List<Integer>> graph = new HashMap<>();
graph.put(0, List.of(1));
graph.put(1, List.of(0, 2, 3));
graph.put(2, List.of(1, 3));
graph.put(3, List.of(1, 2));

import java.util.*;

void bfs(Map<Integer, List<Integer>> graph, int start) {
    Set<Integer> visited = new HashSet<>();
    Queue<Integer> queue = new LinkedList<>();

    visited.add(start);
    queue.add(start);

    while (!queue.isEmpty()) {
        int node = queue.poll();
        System.out.print(node + " ");

        for (int neighbor : graph.get(node)) {
            if (!visited.contains(neighbor)) {
                visited.add(neighbor);
                queue.add(neighbor);
            }
        }
    }
}

void dfs(Map<Integer, List<Integer>> graph, int node, Set<Integer> visited) {
    visited.add(node);
    System.out.print(node + " ");

    for (int neighbor : graph.get(node)) {
        if (!visited.contains(neighbor)) {
            dfs(graph, neighbor, visited);
        }
    }
}

// الاستدعاء:
dfs(graph, 0, new HashSet<>());

void dfsIterative(Map<Integer, List<Integer>> graph, int start) {
    Set<Integer> visited = new HashSet<>();
    Stack<Integer> stack = new Stack<>();
    stack.push(start);

    while (!stack.isEmpty()) {
        int node = stack.pop();
        if (visited.contains(node)) continue;
        visited.add(node);
        System.out.print(node + " ");

        for (int neighbor : graph.get(node)) {
            if (!visited.contains(neighbor)) {
                stack.push(neighbor);
            }
        }
    }
}

boolean hasCycle(Map<Integer, List<Integer>> graph, int node,
                 Set<Integer> visited, int parent) {
    visited.add(node);
    for (int neighbor : graph.get(node)) {
        if (!visited.contains(neighbor)) {
            if (hasCycle(graph, neighbor, visited, node)) return true;
        } else if (neighbor != parent) {
            return true; // وجدنا دورة
        }
    }
    return false;
}

List<Integer> shortestPath(Map<Integer, List<Integer>> graph, int start, int end) {
    Map<Integer, Integer> parent = new HashMap<>();
    Queue<Integer> queue = new LinkedList<>();
    queue.add(start);
    parent.put(start, -1);

    while (!queue.isEmpty()) {
        int node = queue.poll();
        if (node == end) break;
        for (int neighbor : graph.get(node)) {
            if (!parent.containsKey(neighbor)) {
                parent.put(neighbor, node);
                queue.add(neighbor);
            }
        }
    }

    // إعادة بناء المسار
    List<Integer> path = new ArrayList<>();
    for (Integer at = end; at != -1; at = parent.get(at)) {
        path.add(at);
    }
    Collections.reverse(path);
    return path;
}

Map<Integer, List<int[]>> weightedGraph = new HashMap<>();
weightedGraph.put(0, List.of(new int[]{1, 4}, new int[]{2, 1}));
weightedGraph.put(1, List.of(new int[]{0, 4}, new int[]{3, 2}));
// {الجار، الوزن}