Beispiel #1
0
        //determine les fils d'un noeud
        public List <Astar> getfils()
        {
            string pos  = getposition();
            int    i    = int.Parse(pos[0].ToString());
            int    j    = int.Parse(pos[1].ToString());
            var    list = new List <Astar>();

            if (i + 1 < size)
            {
                // i+1 permutation
                int[,] m = (int[, ])matrice.Clone();
                int x;
                x           = m[i, j];
                m[i, j]     = m[i + 1, j];
                m[i + 1, j] = x;
                //affecter a une node
                Astar s = new Astar();
                s.matrice    = m;
                s.size       = size;
                s.arrive     = this.arrive;
                s.Cout       = this.Cout + 1;
                s.Heristique = s.calculer_heutstique();
                s.Coutheur   = s.Cout + s.Heristique;
                list.Add(s);
            }

            if (i - 1 >= 0)
            {
                // i+1 permutation
                int[,] m = (int[, ])matrice.Clone();
                int x;
                x           = m[i, j];
                m[i, j]     = m[i - 1, j];
                m[i - 1, j] = x;
                //affecter a une node
                Astar s1 = new Astar();
                s1.matrice    = m;
                s1.size       = size;
                s1.arrive     = this.arrive;
                s1.Cout       = this.Cout + 1;
                s1.Heristique = s1.calculer_heutstique();
                s1.Coutheur   = s1.Cout + s1.Heristique;
                list.Add(s1);
            }

            if (j + 1 < size)
            {
                // i+1 permutation
                int[,] m = (int[, ])matrice.Clone();
                int x;
                x           = m[i, j];
                m[i, j]     = m[i, j + 1];
                m[i, j + 1] = x;
                //affecter a une node
                Astar s2 = new Astar();
                s2.matrice    = m;
                s2.arrive     = this.arrive;
                s2.size       = size;
                s2.Cout       = this.Cout + 1;
                s2.Heristique = s2.calculer_heutstique();
                s2.Coutheur   = s2.Cout + s2.Heristique;
                list.Add(s2);
            }

            if (j - 1 >= 0)
            {
                // i+1 permutation
                int[,] m = (int[, ])matrice.Clone();
                int x;
                x           = m[i, j];
                m[i, j]     = m[i, j - 1];
                m[i, j - 1] = x;
                //affecter a une node
                Astar s3 = new Astar();
                s3.matrice    = m;
                s3.size       = size;
                s3.arrive     = this.arrive;
                s3.Cout       = this.Cout + 1;
                s3.Heristique = s3.calculer_heutstique();
                s3.Coutheur   = s3.Cout + s3.Heristique;
                list.Add(s3);
            }
            return(list);
        }
Beispiel #2
0
        static void Main(string[] args)
        {
            //PriorityQueue<Node> ouverture = new PriorityQueue<Node>();

            Console.Title = "Le taquin ";

            Console.BufferHeight    = 300;
            Console.WindowHeight    = 42;
            Console.BackgroundColor = ConsoleColor.DarkBlue;
            Console.ForegroundColor = ConsoleColor.Yellow;

            //Le Menu principal
            Menu();
            int rep = 0;

            do
            {
                Console.SetCursorPosition(40, 15);
                Console.WriteLine("Taper votre choix : ");
                Console.SetCursorPosition(40, 16);
                string Response = Console.ReadLine();
                if (int.TryParse(Response, out rep))
                {
                    rep = int.Parse(Response);
                }
                else
                {
                    Console.Write("Choix incorrecte");
                }
            } while (rep > 3 || rep < 1);


            Console.Clear();

            // La saisie de la taille de la matrice
            int size = 0;

            do
            {
                Console.WriteLine("Donnez la taille de la martice");
                string sz = Console.ReadLine();
                if (int.TryParse(sz, out size))
                {
                    size = int.Parse(sz);
                }
                else
                {
                    Console.Write("Choix incorrecte");
                }
            } while (size == 0);

            //LA saisie de matrice de depart
            var Matrice_depart = new int[size, size];

            Console.WriteLine("Donner la matrice de depart!");
            for (int i = 0; i < size; i++)
            {
                for (int j = 0; j < size; j++)
                {
                    Console.WriteLine("Donner M[{0},{1}]", i, j);
                    string s = Console.ReadLine();
                    if (int.TryParse(s, out Matrice_depart[i, j]))
                    {
                        Matrice_depart[i, j] = int.Parse(s);
                    }
                    else
                    {
                        Console.WriteLine("Vous devez saisir une entier");
                        j--;
                    }
                }
            }

            //LA saisie de matrice d'arrive
            var matrice_arrive = new int[size, size];

            Console.WriteLine("Donner la matrice de d'arrivee!");
            for (int i = 0; i < size; i++)
            {
                for (int j = 0; j < size; j++)
                {
                    Console.WriteLine("Donner M[{0},{1}]", i, j);
                    string s = Console.ReadLine();
                    if (int.TryParse(s, out matrice_arrive[i, j]))
                    {
                        matrice_arrive[i, j] = int.Parse(s);
                    }
                    else
                    {
                        Console.WriteLine("Vous devez saisir une entier");
                        j--;
                    }
                }
            }

            Console.WriteLine("Matrice d'arrivée");
            Afficher(matrice_arrive, size);

            Console.WriteLine("Matrice de depart");
            Afficher(Matrice_depart, size);
            Console.ReadKey(true);

            if (rep == 1)
            {
                BestFirstSearch firstnode = new BestFirstSearch();
                firstnode.matrice    = Matrice_depart;
                firstnode.arrive     = matrice_arrive;
                firstnode.size       = size;
                firstnode.Heristique = firstnode.calculer_heutstique();
                Console.WriteLine("Heristique" + firstnode.calculer_heutstique());
                Console.WriteLine();
                firstnode.jouer();
            }
            else if (rep == 2)
            {
                Coutuniforme node = new Coutuniforme();
                node.matrice = Matrice_depart;
                node.arrive  = matrice_arrive;
                node.size    = size;
                node.Cout    = 0;
                Console.WriteLine("Cout : " + node.Cout);
                Console.WriteLine();
                node.jouer();
            }
            else if (rep == 3)
            {
                Astar node = new Astar();
                node.matrice    = Matrice_depart;
                node.arrive     = matrice_arrive;
                node.size       = size;
                node.Cout       = 0;
                node.Heristique = node.calculer_heutstique();
                node.Coutheur   = node.Heristique;
                node.jouer();
            }

            Console.ReadKey(true);
        }
Beispiel #3
0
        public void jouer()
        {
            int[,] arrive = this.arrive;
            var fermeture = new List <Astar>();
            var ouverture = new List <Astar>();
            //Afficher(Matrice_depart);

            //creation de l'arbre
            Astar n = new Astar();

            n.matrice    = this.matrice;
            n.Cout       = this.Cout;
            n.Heristique = this.Heristique;
            n.size       = this.size;
            n.Coutheur   = this.Coutheur;
            n.arrive     = arrive;
            var racine = new Astar();

            racine.matrice = this.matrice;
            ouverture.Add(n);
            //Afficher(Matrice_depart);
            //Console.WriteLine("heuristique :" + n.calculer_heutstique(Matrice_depart));
            List <Astar> l = new List <Astar>();

            while (ouverture[0].Heristique != 0)
            {
                n      = ouverture[0];
                l      = n.getfils();
                n.fils = l;
                foreach (var x in l)
                {
                    for (int i = 0; i < fermeture.Count; i++)
                    {
                        if (fermeture[i].Equals(x))
                        {
                            if (x.Coutheur <= fermeture[i].Coutheur)
                            {
                                fermeture.RemoveAt(i);
                            }
                        }
                    }
                    if (!ouverture.Contains(x))
                    {
                        ouverture.Add(x);
                    }
                }
                fermeture.Add(ouverture[0]);
                ouverture.RemoveAt(0);
                ouverture = ouverture.OrderBy(o => o.Coutheur).ToList();

                //Afficher l'ouverture
                Console.WriteLine("Ouverture");
                foreach (var x in ouverture)
                {
                    Afficher(x.matrice, x.size);
                    Console.WriteLine("Cout :" + x.Cout);
                    Console.WriteLine("Heuristiue :" + x.Heristique);
                    Console.WriteLine("Cout + heuristique :" + x.Coutheur);
                }

                Console.WriteLine("-----------------------------------------");

                //affichage de la fermeture
                Console.WriteLine("fermeture");
                foreach (var x in fermeture)
                {
                    Afficher(x.matrice, x.size);
                    Console.WriteLine("Cout :" + x.Cout);
                    Console.WriteLine("Heuristiue :" + x.Heristique);
                    Console.WriteLine("Cout + heuristique :" + x.Coutheur);
                }
                // Console.ReadKey(true);
                Console.Clear();
            }


            //Afficher l'ouverture
            Console.WriteLine("Ouverture");
            foreach (var x in ouverture)
            {
                Afficher(x.matrice, x.size);
                Console.WriteLine("Cout :" + x.Cout);
                Console.WriteLine("Heuristiue :" + x.Heristique);
                Console.WriteLine("Cout + heuristique :" + x.Coutheur);
            }


            //affichage de la fermeture
            Console.WriteLine("fermeture");
            foreach (var x in fermeture)
            {
                Afficher(x.matrice, x.size);
                Console.WriteLine("Cout :" + x.Cout);
                Console.WriteLine("Heuristiue :" + x.Heristique);
                Console.WriteLine("Cout + heuristique :" + x.Coutheur);
            }
        }