d = {
0: [1, 2, 3, 4, 5],
1: [4, 5, 6],
2: [1, 3, 4, 5],
3: [5, 6, 7],
4: [7, 8],
5: [8],
6: [5, 7],
7: [8],
8: [],
}

def sansSuccesseur(d) :
    """qui renvoie un sommet sans successeur"""
    for c in d : 
        if len(d[c])==0: return c
        
# print(sansSuccesseur(d) )
    
def predecesseurs(d, j) :
    """qui renvoie la liste de tous les prédécesseurs du sommet j"""
    L=[]
    for c in d :
        if j in d[c] : L.append(c)
    return L

# print(predecesseurs(d,8) )

def supprimeSommet(d, j) :
    """qui supprime un sommet j du graphe ainsi que tous les sommets possibles dans les listes associées"""
    d2={}
    for c in d:
        if c!=j: d2[c]=d[c]
    for c in d2:
        if j in d2[c]: d2[c].remove(j)
    return d2
# print(supprimeSommet(d, 8))
 
def noyau(d) :
    """qui renvoie la liste des sommets constituant le noyau de (S,A)"""
    L=[]
    #intialisation
    s=sansSuccesseur(d)
    L.append(s)
    M=predecesseurs(d, s)
    for i in M:
        d=supprimeSommet(d, i)
    while len(M)>1:
        s=sansSuccesseur(d)
        L.append(s)
        M=predecesseurs(d, s)
        for i in M:
            d=supprimeSommet(d, i)
    return L

L=noyau(d)    
print(L)

##
import numpy as np
import random as rd

def h(p):
    #pour faire un exemple !
    return rd.random()*p*(10)
    
def minimax(p, n):
    if n == 0 or successeurs(p) == []:
		return h(p)
	mini = np.inf
	for pk in successeurs(p):
		s = maximin(pk, n - 1)
		if s < mini:
			mini = s
	return mini
	
def maximin(p, n):
	if n == 0 or successeurs(p) == []:
		return h(p)
	maxi = -np.inf
	for pk in successeurs(p):
		s = minimax(pk, n - 1)
		if s > maxi:
			maxi = s
	return maxi
	
##
def minimax(alpha, beta, p, n):
	if n == 0 or successeurs(p) == []:
		return h(p)
	mini = np.inf
	for pk in successeurs(p):
		s = maximin(alpha, beta, pk, n-1)
		if s < mini:
			mini = s
		if mini <= alpha:
			return mini
		beta = min(beta, mini)
	return mini
	
def maximin(alpha, beta, p, n):
	if n == 0 or successeurs(p) == []:
		return h(p)
	maxi = -np.inf
	for pk in successeurs(p):
		s = minimax(alpha, beta, pk, n-1)
		if s > maxi:
			maxi = s
		if maxi >= beta:
			return maxi
		alpha = max(alpha, maxi)
	return maxi