Search Graph Nodes Lintcode

Given a undirected graph, a node and a target, return the nearest node to given node which value of it is target, return NULL if you can't find.

There is a mapping store the nodes' values in the given parameters.

 Notice

It's guaranteed there is only one available solution

Have you met this question in a real interview? 

Yes

Example

2------3  5
 \     |  | 
  \    |  |
   \   |  |
    \  |  |
      1 --4
Give a node 1, target is 50

there a hash named values which is [3,4,10,50,50], represent:
Value of node 1 is 3
Value of node 2 is 4
Value of node 3 is 10
Value of node 4 is 50
Value of node 5 is 50

Return node 4

这道题思路就是bfs，求最短路径一般都用bfs。

一开始忘记了如果这个点本身的点就是要查的点的情况。发现了以后又加了一个if判断。

public class Solution {
    /**
     * @param graph a list of Undirected graph node
     * @param values a hash mapping, <UndirectedGraphNode, (int)value>
     * @param node an Undirected graph node
     * @param target an integer
     * @return the a node
     */
    public UndirectedGraphNode searchNode(ArrayList<UndirectedGraphNode> graph,
                                          Map<UndirectedGraphNode, Integer> values,
                                          UndirectedGraphNode node,
                                          int target) {
        Queue<UndirectedGraphNode> q = new LinkedList<>();
        q.offer(node);
        HashSet<UndirectedGraphNode> visited = new HashSet<>();
        visited.add(node);
        while (!q.isEmpty()) {
            UndirectedGraphNode n = q.poll();
            if (values.get(n) == target) {
                    return n;
            }
            for (UndirectedGraphNode subN : n.neighbors) {
                if (visited.contains(subN)) {
                    continue;
                }
                if (values.get(subN) == target) {
                    return subN;
                }
                q.offer(subN);
                visited.add(subN);
            }
        }
        return null;
    }
}

看了下答案还是很简洁的，每个点都会入queue一次，所以可以在外层判断。可是只是可能会慢一点点。

但是代码很简洁。

/**
 * Definition for graph node.
 * class UndirectedGraphNode {
 *     int label;
 *     ArrayList<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { 
 *         label = x; neighbors = new ArrayList<UndirectedGraphNode>(); 
 *     }
 * };
 */
public class Solution {
    /**
     * @param graph a list of Undirected graph node
     * @param values a hash mapping, <UndirectedGraphNode, (int)value>
     * @param node an Undirected graph node
     * @param target an integer
     * @return the a node
     */
    public UndirectedGraphNode searchNode(ArrayList<UndirectedGraphNode> graph,
                                          Map<UndirectedGraphNode, Integer> values,
                                          UndirectedGraphNode node,
                                          int target) {
        Queue<UndirectedGraphNode> q = new LinkedList<>();
        HashSet<UndirectedGraphNode> visited = new HashSet<>();
        
        q.offer(node);
        visited.add(node);
        
        while (!q.isEmpty()) {
            UndirectedGraphNode n = q.poll();
            if (values.get(n) == target) {
                return n;
            }
            for (UndirectedGraphNode subN : n.neighbors) {
                if (!visited.contains(subN)) {
                    q.offer(subN);
                    visited.add(subN);
                }
            }
        }
        return null;
    }
}