コード例 #1
0
    // recursive DFS to detect cycles
    public boolean hasCycle() {
      // firstly check if this node is a visited clean node
      // this pre-check will avoid repeat search and save time
      if (cleanNode) {
        return false;
      }

      // if our curr node is a visited node, then it means we got a back edge in current path, so
      // there is a cycle
      if (visited) {
        return true;
      }

      // mark visited in current search
      visited = true;

      // check its neighbor nodes
      for (Node node : nodes) {
        // recursivly search each next node
        if (node.hasCycle()) {
          return true;
        }
      }

      // reset node as unvisited to avoid the impact on next search
      visited = false;
      // if there is no cycle in this node, we will set it as cleanNode
      cleanNode = true;
      return false;
    }
コード例 #2
0
    private boolean hasCycle(StringBuilder sb) {
      // we need put the root node first. To be convenient we want start DFS from any node, not the
      // node
      // without prerequisites or with most prerequisites. So we will build the string backward.
      // We will start build the string after we reach the bottom (the root node). Therefore, in DFS
      // we should use "depends on" relation, where we put root node to the bottom

      // cleanNode check first, so we can set and reset "visited" freely
      if (cleanNode) return false;
      if (visited) return true;
      visited = true;

      for (Node node : nodes) {
        if (node.hasCycle(sb)) return true;
      }

      cleanNode = true;
      visited = false;
      sb.append(c);
      return false;
    }
コード例 #3
0
  public boolean canFinish(int numCourses, int[][] prerequisites) {
    // create a node list, so we can visit node easier
    Node[] nodes = new Node[numCourses];

    // initialize each node
    for (int i = 0; i < nodes.length; i++) {
      nodes[i] = new Node();
    }

    // update neighbors of each node
    for (int[] pair : prerequisites) {
      nodes[pair[0]].addNode(nodes[pair[1]]);
    }

    // scan array to check if there is any cycle
    for (Node node : nodes) {
      if (node.hasCycle()) return false;
    }

    return true;
  }