You are given a directed graph of n nodes numbered from 0 to n – 1, where each node has at most one outgoing edge.
The graph is represented with a given 0-indexed array edges of size n, indicating that there is a directed edge from node i to node edges[i]. If there is no outgoing edge from i, then edges[i] == -1.
You are also given two integers node1 and node2.
Return the index of the node (closest node) that can be reached from both node1 and node2, such that the maximum between the distance from node1 to that node, and from node2 to that node is minimized. If there are multiple answers, return the node with the smallest index, and if no possible answer exists, return -1.
Note: that edges may contain cycles.
Example 1:
Input: edges = [2,2,3,-1], node1 = 0, node2 = 1
Output: 2
Explanation: The distance from node 0 to node 2 is 1, and the distance from node 1 to node 2 is 1.
The maximum of those two distances is 1. It can be proven that we cannot get a node with a smaller maximum distance than 1, so we return node 2.
source: https://leetcode.com/problems/find-closest-node-to-given-two-nodes/description/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
class Solution { public int closestMeetingNode(int[] edges, int node1, int node2) { Map<Integer, List<Integer>> graph = new HashMap<>(); //create an adjacency list for(int i=0;i<edges.length;i++){ if(edges[i]!=-1){ List<Integer> listA = graph.getOrDefault(i, new ArrayList<>()); listA.add(edges[i]); graph.put(i, listA); } } //an array to keep track of distance of a node from node1 int[] dist1 = new int[edges.length]; Arrays.fill(dist1, Integer.MAX_VALUE); //an array to keep track of distance of a node from node2 int[] dist2 = new int[edges.length]; Arrays.fill(dist2, Integer.MAX_VALUE); //breadth first search with start node as node1 bfs(graph, node1, dist1); //breadth first search with start node as node2 bfs(graph, node2, dist2); int minDist = Integer.MAX_VALUE; int minNode = -1; for(int i=0;i<dist1.length;i++){ //find the maximum of two distances int max = Math.max(dist1[i], dist2[i]); //update if max is less than min distance so far if(max < minDist){ minNode = i; minDist = max; } } return minDist!=Integer.MAX_VALUE?minNode:-1; } private void bfs(Map<Integer, List<Integer>> graph, int start, int[] dist){ Queue<Integer> next = new LinkedList<>(); next.add(start); int level = 0; //to handle cycle in the graph boolean[] visited = new boolean[dist.length]; while(!next.isEmpty()){ int size = next.size(); for(int i=0;i<size;i++){ int node = next.poll(); dist[node] = level; //mark node as visited visited[node] = true; if(graph.containsKey(node)){ for(int adj: graph.get(node)){ //only add the nodes that are not visited yet if(!visited[adj]) next.add(adj); } } } //increment the level level++; } } } |