import queue

# -*- coding: utf-8 -*-
"""Graph module.

Provide an implementation of graphs with adjacency lists.

In a graph, vertices are considered numbered from 0 to the order of the graph
minus one. The vertex key can then be used to access its
adjacency list.

"""


class Graph:
    """ Simple class for graph: adjacency lists

    Attributes:
        order (int): Number of vertices.
        directed (bool): True if the graph is directed. False otherwise.
        adjlists (List[List[int]]): Lists of connected vertices for each vertex.

    """

    def __init__(self, order, directed, labels=None):
        """Init graph, allocate adjacency lists

        Args:
            order (int): Number of nodes.
            directed (bool): True if the graph is directed. False otherwise.
            labels (list[str]): optionnal vector of vertex labels
        """

        self.order = order
        self.directed = directed
        self.adjlists = []
        for _ in range(order):
            self.adjlists.append([])
        self.labels = labels

    def addedge(self, src, dst):
        """Add egde to graph.

        Args:
            src (int): Source vertex.
            dst (int): Destination vertex.

        Raises:
            IndexError: If any vertex index is invalid.

        """
        if src >= self.order or src < 0:
            raise IndexError("Invalid src index")
        if dst >= self.order or dst < 0:
            raise IndexError("Invalid dst index")

        self.adjlists[src].append(dst)
        if not self.directed and dst != src:
            self.adjlists[dst].append(src)


    def addvertex(self, number=1, labels=None):
        """Add number vertices to graph.

        Args:
            ref (Graph).
            number (int): Number of vertices to add.

        """

        # Increment order and extend adjacency list
        self.order += number
        for _ in range(number):
            self.adjlists.append([])
        if labels:
            self.labels += labels

    def removeedge(self, src, dst):
        """Remove egde from the graph.

        Args:
            src (int): Source vertex.
            dst (int): Destination vertex.

        Raises:
            IndexError: If any vertex index is invalid.

        """

        if src >= self.order or src < 0:
            raise IndexError("Invalid src index")
        if dst >= self.order or dst < 0:
            raise IndexError("Invalid dst index")
        if dst in self.adjlists[src]:
            self.adjlists[src].remove(dst)
            if not self.directed and dst != src:
                self.adjlists[dst].remove(src)

def sortgraph(G):
    """
    sorts adjacency lists -> to have same results as those asked in tutorials/exams
    """
    for i in range(G.order):
        G.adjlists[i].sort()

def dot(G):
    """Dot format of graph.

    Args:
        Graph

    Returns:
        str: String storing dot format of graph.

    """

    if G.directed:
        s = "digraph {\n"
        for x in range(G.order):
            if G.labels:
                s += "  " + str(x) + '[label = "' + G.labels[x] + '"]\n'
            else:
                s += "  " + str(x) + '\n'
            for y in G.adjlists[x]:
                s += str(x) + " -> " + str(y) + '\n'
    else:
        s = "graph {\n"
        for x in range(G.order):
            if G.labels:
                s += "  " + str(x) + '[label = "' + G.labels[x] + '"]\n'
            else:
                s += "  " + str(x) + '\n'
            for y in G.adjlists[x]:
                if x <= y:
                    s += str(x) + " -- " + str(y) + '\n'
    return s + '}'

def display(G, eng=None):
    """
    *Warning:* Made for use within IPython/Jupyter only.
    eng: graphivz.Source "engine" optional argument (try "neato", "fdp", "sfdp", "circo")

    """

    try:
        from graphviz import Source
        from IPython.display import display
    except:
        raise Exception("Missing module: graphviz and/or IPython.")
    display(Source(dot(G), engine = eng))


# load / save gra format

def load(filename):
    """Build a new graph from a GRA file.

    Args:
        filename (str): File to load.

    Returns:
        Graph: New graph.

    Raises:
        FileNotFoundError: If file does not exist.

    """

    f = open(filename)
    lines = f.readlines()
    f.close()

    infos = {}
    i = 0
    while '#' in lines[i]:
        (key, val) = lines[i][1:].strip().split(": ")
        infos[key] = val
        i += 1

    directed = bool(int(lines[i]))
    order = int(lines[i+1])

    if infos and "labels" in infos:
        labels = infos["labels"].split(',') #labels is a list of str
        G = Graph(order, directed, labels)  # a graph with labels
    else:
        G = Graph(order, directed)  # a graph without labels
    if infos:
        G.infos = infos

    for line in lines[i+2:]:
        edge = line.strip().split(' ')
        (src, dst) = (int(edge[0]), int(edge[1]))
        G.addedge(src, dst)
    return G


def save(G, fileOut):
    gra = ""
    if G.labels:
        lab = "#labels: "
        for i in range(G.order - 1):
            lab += G.labels[i] + ','
        lab += G.labels[-1]
        gra += lab + '\n'
    gra += str(int(G.directed)) + '\n'
    gra += str(G.order) + '\n'
    for x in range(G.order):
        for y in G.adjlists[x]:
            if G.directed or x >= y:
                gra += str(x) + " " + str(y) + '\n'
    fout = open(fileOut, mode='w')
    fout.write(gra)
    fout.close()


# -*- coding: utf-8 -*-
"""Graph module.

Provide an implementation of graphs with adjacency matrix.
This can also be called static implementation.

In a graph, vertices are considered numbered from 0 to the order of the graph
minus one.

"""


class GraphMat:
    """ Simple class for static graph.

    Attributes:
        order (int): Number of vertices.
        directed (bool): True if the graph is directed. False otherwise.
        adj (List[List[int]]): Adjacency matrix
    """

    def __init__(self, order, directed):
        """
        Args:
            order (int): Number of nodes.
            directed (bool): True if the graph is directed. False otherwise.
        """

        self.order = order
        self.directed = directed
        self.adj = [[0 for j in range(order)] for i in range(order)]


    def addedge(self, src, dst):
        """Add egde to graph.

        Args:
            src (int): Source vertex.
            dst (int): Destination vertex.

        Raises:
            IndexError: If any vertex index is invalid.

        """

        if src >= self.order or src < 0:
            raise IndexError("Invalid src index")
        if dst >= self.order or dst < 0:
            raise IndexError("Invalid dst index")

        self.adj[src][dst] += 1
        if not self.directed and dst != src:
            self.adj[dst][src] += 1



def dot(G):
    """Dot format of graph.

    Args:
        GraphMat

    Returns:
        str: String storing dot format of graph.

    """

    if G.directed:
        s = "digraph {\n"
        link = " -> "
        for x in range(G.order):
            for y in range(G.order):
                s += (str(x) + link + str(y) + '\n') * G.adj[x][y]
    else:
        s = "graph {\n"
        link = " -- "
        for x in range(G.order):
            for y in range(x+1):
                s += (str(x) + link + str(y) + '\n') * G.adj[x][y]
    return s + '}'



def display(G, eng=None):
    """
    *Warning:* Made for use within IPython/Jupyter only.
    eng: graphivz.Source "engine" optional argument (try "neato", "fdp", "sfdp", "circo")

    """

    try:
        from graphviz import Source
        from IPython.display import display
    except:
        raise Exception("Missing module: graphviz and/or IPython.")
    display(Source(dot(G), engine = eng))


# load / save gra format    (do not manage labels and other infos)

def load(filename,):
    """Build a new graph from a GRA file.

    Args:
        filename (str): File to load.

    Returns:
        Graph: New graph.

    Raises:
        FileNotFoundError: If file does not exist.

    """

    f = open(filename)
    directed = bool(int(f.readline()))
    order = int(f.readline())
    g = GraphMat(order, directed)
    for line in f.readlines():
        edge = line.strip().split(' ')
        (src, dst) = (int(edge[0]), int(edge[1]))
        g.addedge(src, dst)
    f.close()
    return g

def save(G, fileOut):
    gra = str(int(G.directed)) + '\n'
    gra += str(G.order) + '\n'
    for x in range(G.order):
        if G.directed:
            n = G.order
        else:
            n = x + 1
        for y in range(n):
            for i in range(G.adj[x][y]):
                gra += str(x) + " " + str(y) + '\n'
    fout = open(fileOut, mode='w')
    fout.write(gra)
    fout.close()

# -*- coding: utf-8 -*-
"""Queue module."""

from collections import deque

class Queue:
    """Simple class for FIFO (first-in-first-out) container."""

    def __init__(self):
        """Init queue."""

        self.elements = deque()

    def enqueue(self, elt):
        """Add an element to the queue.

        Args:
            elt (Any): Element to enqueue.

        """

        self.elements.append(elt)

    def dequeue(self):
        """Remove and return next element from the queue.

        Returns:
            Any: Element from the queue.

        Raises:
            IndexError: If queue is empty.

        """

        return self.elements.popleft()

    def isempty(self):
        """Check whether queue is empty.

        Returns:
            bool: True if queue is empty, False otherwise.

        """

        return len(self.elements) == 0

G = Graph(10, False)
G.adjlists = [[4, 4, 1, 3],
               [0],
               [6, 6, 6, 5, 7],
               [0],
               [0, 0, 9],
               [2, 7, 8],
               [2, 2, 2, 7],
               [2, 6, 5, 8],
               [7, 5, 8],
               [4]]



def __smallest_level(G, M, src, perLevel):
    cur = Queue()
    cur.enqueue(src)
    cur.enqueue(None)
    M[src] = True
    temp = []
    while not cur.isempty():
        x = cur.dequeue()
        if x is None:
            if (len(temp) != 0 and temp != [src]):
                perLevel.append(temp)
            temp = []
        else:
            temp.append(x)
            for adj in G.adjlists[x]:
                if not M[adj]:
                    M[adj] = True
                    cur.enqueue(adj)
            cur.enqueue(None)
def smallest_level(G, src):
    M = [False] * G.order
    perLevel = []
    __smallest_level(G, M, src, perLevel)
    min = perLevel[0]
    for element in perLevel:
        if len(element) < len(min):
            min = element
    return min

smallest_level(G, 0)