#!/usr/bin/env python3
def creerTableau(n):
    return [0]*n

#Premiere partie
#1.

def creerTabVide(n):
    T=creerTableau(n+1)
    for i in range(n+1):
        T[i]=0
    return T
#2.
def estDansTab(tab, x):
    for el in tab[1:tab[0]+1]:
        if el==x:
            return True
    return False
"""
Dans le pire cas, c'est à dire le cas ou l'élément recherché
n'est pas dans le tableau, la boucle parcourera la totalité de la liste 
et effectuera un test. Or il y a n éléments dans la liste, donc
le test sera effectué n fois. Par conséquent, la complexité de la 
fonction est O(n)
"""

#3.
def ajouteDansTab(tab, x):
    if not estDansTab(tab, x):
        tab[tab[0] + 1] = x
        tab[0]+=1
"""
Si la liste tab est pleine et que x n'est pas encore dans la liste initiale
, la procédure renvoira une erreur car l'index maximal sera dépassé.

Dans tous les cas, le tableau ne contiendra pas x.
La procedure appellera d'abord estDansTab puis executera deux instructions.
par conséquent, la complexité sera celle de estDansTab.
La procédure a une complexité O(n)
"""

#Deuxième partie

#1.
plan1=[ [5, 7],
       [2, 2, 3, 0, 0],
       [3, 1, 3, 5, 0],
       [4, 1, 2, 4, 5],
       [2, 3, 5, 0, 0],
       [3, 2, 3, 4, 0] ]
plan2=[ [5, 4],
       [1, 2, 0, 0, 0],
       [3, 1, 3, 4, 0],
       [1, 2, 0, 0, 0],
       [2, 2, 5, 0, 0],
       [1, 4, 0, 0, 0]]
#2.
def creerPlanSansRoute(n):
    return [[n,0]]+[creerTabVide(n-1) for _ in range(n)]

#3.
def estVoisine(plan, x, y):
    return estDansTab(plan[x], y)

#4.
def ajouteRoute(plan, x, y):
    plan[0][1] += 1
    ajouteDansTab(plan[x], y)
    ajouteDansTab(plan[y], x)
"""
Il y a n villes dans le plan. donc chaque ville peut avoir, au plus
n-1 voisines. Les tableaux représentant les voisines de chaque ville
peuvent contenir au plus n-1 élément. Il n'y aura donc pas de dépassement."""

#5.

def afficheToutesLesRoutes(plan):
    routes=[None]
    for i in range(1,plan[0][0] + 1):
        for voisine in plan[i][1:plan[i][0] + 1]:
            for route in routes:
                if route == {i, voisine}:
                    break
            if route is None:
                routes.insert(0, {i, voisine})
                    
    print("["+", ".join([str(tuple(route)).replace(", ", " - ") for route in routes[:-1][::-1]])+"]")
"""
Dans le pire des cas, la fonction effectura :
    n fois la suite d'opération qui consiste à effectuer:
        n-1 fois la suite d'operation qui consiste à
            boucler parmi les routes déjà trouvées.
    ainsi, dans le pire des cas, la procédure aura une complexité
    O(n(n-1)m = O (mn² - mn)' = O(mn²)
        
"""
plan3=creerPlanSansRoute(11)
ajouteRoutes = lambda plan, x : [ajouteRoute(plan, *route) for route in x]
ajouteRoutes(plan3, [(1,6),(1,2),(2,7),(6,7),(6,5),(5,10),(10,11),(11,9),(9,8),(8,7),(8,3),(3,4),(8,4)])

#Troisième partie

#Préliminaire
import random
def entierAleatoire(k):
    return random.randint(1,k)
#1.

def coloriageAleatoire(plan, couleur, k, s, t):
