KeyValuePair <int, CheckersState> MaxValue(CheckersState state, int alpha, int beta, int depth)
        {
            // Si l'etat est un etat terminal de l'arbre on retourne une valeur
            if (state.Terminal || depth >= m_depthMax)
            {
                return(new KeyValuePair <int, CheckersState>(state.Utility, state));
            }

            //Debug.WriteLine("Max profondeur : "+depth);
            int           utility       = int.MinValue;
            CheckersState bestSuccessor = state;
            // Pour tous les successeurs de l'etat on recupere le successeur qui renvoie la plus grande utilite minimum
            List <CheckersState> successors = state.Successors();

            if (successors.Count == 1 && depth == 0)
            {
                return(new KeyValuePair <int, CheckersState>(successors[0].Utility, successors[0]));
            }
            foreach (CheckersState nextState in successors)
            {
                int successorUtility = MinValue(nextState, alpha, beta, depth + 1).Key;
                if (utility < successorUtility)
                {
                    utility       = successorUtility;
                    bestSuccessor = nextState;
                }

                /*else if (utility == successorUtility)
                 * {
                 *  int choose = rand.Next(0, 2);
                 *  bestSuccessor = choose > 0 ? bestSuccessor : nextState;
                 * }*/
                if (utility >= beta)
                {
                    //Debug.WriteLine("Fin max profondeur : " + depth + ", utilite : " + utility);
                    return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
                }
                alpha = Math.Max(alpha, utility);
            }
            //Debug.WriteLine("Fin max profondeur : " + depth + ", utilite : " + utility);
            return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
        }
        /// <summary>
        /// Retourne le pire etat successeurs(pour l'agent) a l'etat propose
        /// </summary>
        /// <param name="state">L'etat propose</param>
        /// <param name="depth">La profondeur dans l'arbre a laquelle on se trouve</param>
        /// <returns>Le pire etat successeurs</returns>
        KeyValuePair <int, CheckersState> MinValue(CheckersState state, int depth)
        {   // Si l'etat est un etat terminal de l'arbre on retourne une valeur
            if (state.Terminal || depth >= m_depthMax)
            {
                return(new KeyValuePair <int, CheckersState>(state.Utility, state));
            }

            int           utility       = int.MaxValue;
            CheckersState bestSuccessor = state;

            // Pour tout les successeurs de l'etat on recupere le successeur qui renvoie la plus petite utilite maximum
            foreach (CheckersState nextState in state.Successors())
            {
                int successorUtility = MaxValue(nextState, depth + 1).Key;
                if (utility > successorUtility)
                {
                    utility       = successorUtility;
                    bestSuccessor = nextState;
                }
            }
            return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
        }