Sum of distance from each node

import java.util.*;

public class GFG {

    static List<Integer> sumOfDistances(int N, List<List<Integer>> edges) {
        
        // Build adjacency list
        List<List<Integer>> adj = new ArrayList<>();
        for(int i = 0; i <= N; i++) adj.add(new ArrayList<>());
        
        for(List<Integer> e : edges) {
            
            // Add both directions since graph is undirected
            adj.get(e.get(0)).add(e.get(1));
            adj.get(e.get(1)).add(e.get(0));
        }

        List<Integer> ans = new ArrayList<>(Collections.nCopies(N + 1, 0));

        // For each node, run BFS and calculate sum of distances
        for(int start = 1; start <= N; start++) {
            
            int[] dist = new int[N + 1];
            Arrays.fill(dist, -1);
            Queue<Integer> q = new LinkedList<>();

            // Start BFS from the current node
            dist[start] = 0;
            q.add(start);

            while(!q.isEmpty()) {
                
                int node = q.poll();

                // Explore all adjacent nodes
                for(int nei : adj.get(node)) {
                    
                    // Visit unvisited neighbors
                    if(dist[nei] == -1) {
                        
                        dist[nei] = dist[node] + 1;
                        q.add(nei);
                    }
                }
            }

            // Sum all distances for this starting node
            int total = 0;
            
            for(int i = 1; i <= N; i++) {
                total += dist[i];
            }
            
            ans.set(start, total);
        }

        return ans;
    }

    public static void main(String[] args) {
        
        
        int N = 5;
        
        List<List<Integer>> edges = Arrays.asList(
            Arrays.asList(1,2), Arrays.asList(1,3),
            Arrays.asList(3,4), Arrays.asList(3,5)
        );

        // Compute result
        List<Integer> result = sumOfDistances(N, edges);

        // Print output
        for(int i = 1; i <= N; i++) {
            System.out.print(result.get(i) + " ");
        }
    }
}

import java.util.*;

public class GFG {

    // First DFS: compute subSize and down values (post-order)
    static void dfs1(int u, int p, List<List<Integer>> adj, int[] subSize, long[] down) {
        
        // Initialize subtree size and down sum for node u
        subSize[u] = 1;
        down[u] = 0;

        // Visit children
        for (int v : adj.get(u)) {
            if (v == p) continue;

            dfs1(v, u, adj, subSize, down);

            // Add child's subtree size
            subSize[u] += subSize[v];

            // All nodes in child's subtree are one edge farther from u than from v
            down[u] += down[v] + subSize[v];
        }
    }

    // Second DFS: reroot and compute ans for all nodes (pre-order)
    static void dfs2(int u, int p, int N, List<List<Integer>> adj, int[] subSize, long[] ans) {
        
        // Visit children and reroot to compute their answers
        for (int v : adj.get(u)) {
            if (v == p) continue;

            // Move root from u to v:
            // Nodes in v's subtree get 1 closer (subtract subSize[v])
            // All other nodes get 1 farther (add N - subSize[v])
            ans[v] = ans[u] - subSize[v] + (N - subSize[v]);

            dfs2(v, u, N, adj, subSize, ans);
        }
    }

    // Wrapper function that computes all distances
    static long[] computeDistances(int N, List<int[]> edges) {

        // Build adjacency list
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i <= N; i++) adj.add(new ArrayList<>());
        for (int[] e : edges) {
            adj.get(e[0]).add(e[1]);
            adj.get(e[1]).add(e[0]);
        }

        int[] subSize = new int[N + 1];
        long[] down = new long[N + 1];
        long[] ans = new long[N + 1];

        // First DFS: compute subtree info
        dfs1(1, 0, adj, subSize, down);

        // Set root answer
        ans[1] = down[1];

        // Second DFS: reroot and compute answers for all nodes
        dfs2(1, 0, N, adj, subSize, ans);

        return ans;
    }

    public static void main(String[] args) {
        
        
        int N = 5;
        List<int[]> edges = Arrays.asList(
            new int[]{1, 2}, new int[]{1, 3},
            new int[]{3, 4}, new int[]{3, 5}
        );

        // Function call
        long[] result = computeDistances(N, edges);

        // Print output
        for (int i = 1; i <= N; i++) {
            System.out.print(result[i] + " ");
        }
    }
}