import java.util.*;

public class UndirectedBreadthFirstMatrix {
  
  int numVertices;                 // Number of vertices, given as input.
  int numEdges;                    // We keep track of the number of edges.

  boolean isWeighted;              // Is this a weighted graph?

  boolean useMatrix = true;        // Adjacency-matrix or list?

  double [][] adjMatrix;           // The matrix. Note: we use "double" to store
                                   // "double" weights, if the graph is weighted.

  int[] visitOrder;                // visitOrder[i] = the i-th vertex to be visited in order.
  int visitCount;                  // We will track visits with this counter.

  LinkedList queue;                // The queue for breadth-first, a java.util.LinkedList.


  public void initialize (int numVertices, boolean isWeighted)
  {
    // Store:

    this.numVertices = numVertices;
    this.isWeighted = isWeighted;


    if (useMatrix) {
      // Create the adjacency matrix.
      adjMatrix = new double [numVertices][];
      for (int i=0; i<numVertices; i++) {
        adjMatrix[i] = new double [numVertices];
      }
      // Already initialized to zero.
    }
    else {
      // Adjacency list ...
    }

    // Other variables:
    visitOrder = new int [numVertices];
    numEdges = 0;

  }



  // Is a vertex ID invalid? Used during insertion.

  boolean outOfBounds (int v)
  {
    if ( (v < 0) || (v >= numVertices) )
      return true;
    return false;
  }
  

  // Insert a given input edge.

  public void insertUndirectedEdge (int startVertex, int endVertex, double weight)
  {
    // Check whether vertex is valid.
    if ( outOfBounds (startVertex) || outOfBounds (endVertex) ) {
      System.out.println ("ERROR: out of bounds: start=" + startVertex + " end=" + endVertex);
      return;
    }

    // Matrix representation:
    if (useMatrix) {

      // If already inserted, flag an error.
      if (adjMatrix[startVertex][endVertex] != 0) {
        System.out.println ("ERROR: edge already inserted: (" + startVertex + "," + endVertex +")");
        return;
      }
    
      // Unweighted graph: use weight 1.0.
      if (! isWeighted) {
        adjMatrix[startVertex][endVertex] = 1.0;
        adjMatrix[endVertex][startVertex] = 1.0;
      }
      else {
        adjMatrix[startVertex][endVertex] = weight;
        adjMatrix[endVertex][startVertex] = weight;
      }

      numEdges ++;
      return;
    } // end-use-Matrix.
    
    // Adj-list implementation ... (not shown)

  }
  

  // Initialize visit information before search.

  void initSearch ()
  {
    // IMPORTANT: all initializations will use "-1". We will test
    // equality with "-1", so it's important not to change this cavalierly.
    visitCount = -1;
    for (int i=0; i<numVertices; i++) {
      visitOrder[i] = -1;
    }
  }

  //-------------------------------------------------------------------------------
  // BREADTH-FIRST SEARCH


  // Implement the interface method for breadth-first search.

  public int[] breadthFirstVisitOrder ()
  {
    // The matrix and adjlist code are fundamentally different.
    if (useMatrix) {
      breadthFirstMatrix ();
    }
    else {
      // Adjacency list ...
    }

    // Return the visit order (a global variable).
    return visitOrder;
  }

  
  // Matrix implementation of breadth-first search.

  void breadthFirstMatrix ()
  {
    // 1. Initialize visit variables.

    initSearch ();


    // 2. Create a queue.

    queue = new LinkedList();

    // 3. Find an unvisited vertex and apply breadth-first search to it.
    //    Note: if the graph is connected, the call with i=0 will result
    //          in visiting all vertices. Nonetheless, we don't know this 
    //          in advance, so we need to march through all the vertices.

    for (int i=0; i<numVertices; i++) {
      if (visitOrder[i] == -1) {

        // We call it "iterative" because depthFirst search is "recursive".
        breadthFirstMatrixIterative (i);

      }
    } 
    
  }
  

  // Apply breadthfirst search to a particular start-vertex (root of the
  // breadth-first tree).

  void breadthFirstMatrixIterative (int u)
  {
    // 1. A fresh queue is used for a new breadth-first search.

    queue.clear();


    // 2. Start with the first vertex: add to REAR of queue using java.util.LinkedList.addLast().
    //    Because LinkedList stores objects, we "objectify" the vertex. A more efficient
    //    implementation would use a separate queue of int's.

    queue.addLast (new Integer(u));


    // 3. As long as the queue has vertices to process...

    while (! queue.isEmpty()) {

      // 3.1 Dequeue and extract vertex using java.util.LinkedList.removeFirst().

      Integer V = (Integer) queue.removeFirst();
      int v = V.intValue();

      // 3.2 If the vertex has been visited, skip.

      if (visitOrder[v] != -1)
        continue;

      // 3.3 Otherwise, set its visit order.

      visitCount++;
      visitOrder[v] = visitCount;


      // 3.4 Next, place its neighbors on the queue.

      for (int i=0; i<numVertices; i++) {

        // 3.4.1 First, check whether vertex i is a neighbor. Also, we avoid self-loops
        //       with the (i != v) test.

        if ( (adjMatrix[v][i] > 0) && (i != v) ) {

          // 3.4.1.1 If not visited, place in queue.
          
          if (visitOrder[i] == -1) {
            queue.addLast (new Integer(i));
          }

        } // endif

      } // end-for

    } // end while

  }
  
}