细分图中的可到达节点

/**
 * Similar to the Java solution, but with the use of Java Streams for constructing the graph and processing the edges.
 * Streams are used to create and process data in a more functional programming style.
 */

import java.util.*;
import java.util.stream.Collectors;

public class ReachableNodesStream {
    public int reachableNodes(int[][] edges, int maxMoves, int n) {
        // Create the graph using Streams
        Map<Integer, Map<Integer, Integer>> graph = Arrays.stream(edges)
            .collect(Collectors.groupingBy(edge -> edge[0], Collectors.toMap(edge -> edge[1], edge -> edge[2])));
        graph.putAll(Arrays.stream(edges)
            .collect(Collectors.groupingBy(edge -> edge[1], Collectors.toMap(edge -> edge[0], edge -> edge[2]))));
        
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
        pq.offer(new int[]{0, 0});
        Map<Integer, Integer> visited = new HashMap<>();
        visited.put(0, 0);
        int result = 0;
        
        while (!pq.isEmpty()) {
            int[] cur = pq.poll();
            int curMoves = cur[0], curNode = cur[1];
            
            if (curMoves > visited.getOrDefault(curNode, 0)) continue;
            result++;
            
            Map<Integer, Integer> neighbors = graph.getOrDefault(curNode, Collections.emptyMap());
            result += neighbors.entrySet().stream()
                .mapToInt(entry -> {
                    int nextNode = entry.getKey(), cnt = entry.getValue();
                    int nextMoves = curMoves + cnt + 1;
                    if (nextMoves <= maxMoves && nextMoves < visited.getOrDefault(nextNode, Integer.MAX_VALUE)) {
                        pq.offer(new int[]{nextMoves, nextNode});
                        visited.put(nextNode, nextMoves);
                    }
                    return Math.min(cnt, maxMoves - curMoves);
                }).sum();
        }
        
        return result;
    }
}