コード例 #1
0
ファイル: AStarSearch.cs プロジェクト: paulhunter/CSC421
        public SearchResults Search(HexagonalTileSearchProblem Problem)
        {
            /* ----- SETUP ----- */
            SearchResults r = new SearchResults();

            if (Problem == null)
            {
                return(r);
            }

            Dictionary <MapTile, MapTile> Paths = new Dictionary <MapTile, MapTile>();

            Dictionary <MapTile, bool> Explored = new Dictionary <MapTile, bool>((int)Problem.SearchSpace.Size);

            foreach (MapTile mt in Problem.SearchSpace.XYTiles())
            {
                Explored.Add(mt, false);
            }

            hSortedList <double, MapTile> Available = new hSortedList <double, MapTile>();

            Available.Add(0, Problem.Start);

            /* ----- SEARCH ----- */

            /* A Star works by evaluating potential paths based on an estimate of
             * there overall path cost to the goal. This is computed as the existing cost
             * from the start to the node, based on the known cost to the current node, and the
             * length of the edge , plus its estimated distance to the goal. If a node has been observed
             * before, or is part of a path already established, the cost via the new route is compared with
             * that of the old, and if cheaper, will be used in placed of the old. In this fashion, the algo is
             * always capable of finding the best route through a graph, but has a fair amount of overhead. */
            MapTile  current = null;
            int      current_cost;
            DateTime start_time = DateTime.Now;

            while (Available.Count != 0)
            {
                if (Available.Count > r.SpaceComplexity)
                {
                    r.SpaceComplexity = Available.Count;
                }

                current      = Available.Pop();
                current_cost = SearchHelper.GetPathLengthFromStart(current, Paths, Problem.Start);

                r.TimeComplexity++;

                Explored[current] = true;

                //If we have recieved the destination, we have completed the search.
                if (current == Problem.Goal)
                {
                    r.Solved = true;
                    break;
                }

                //If we have not found the destination, catalog the available operations
                //from this mapTile.
                foreach (MapTile mt in current.GetNeighbours())
                {
                    if (Explored[mt] == false)
                    {
                        //We have not previously seen this location.
                        if (!Paths.ContainsKey(mt))
                        {
                            Paths.Add(mt, current);
                            Available.Add(
                                current_cost + 1 //All nodes have a distance of one from their neighbour
                                + Heuristic.Calculate(mt, Problem.Goal),
                                mt);
                        }
                        else
                        {
                            int     old_cost  = SearchHelper.GetPathLengthFromStart(mt, Paths, Problem.Start);
                            MapTile oldParent = Paths[mt];
                            Paths[mt] = current;
                            int new_cost = SearchHelper.GetPathLengthFromStart(mt, Paths, Problem.Start);

                            //If the new cost to the tile is more than our previous
                            //path to this tile, we want to keep our previous parent assignment
                            if (new_cost > old_cost)
                            {
                                Paths[mt] = oldParent;
                            }
                            else
                            {
                                Available.Add(
                                    current_cost + 1 +
                                    Heuristic.Calculate(mt, Problem.Goal),
                                    mt);
                            }
                        }
                    }
                }
            }
            DateTime end_time = DateTime.Now;

            r.TimeInMilliseconds = (int)(end_time - start_time).TotalMilliseconds;

            /* ----- BACKTRACK PATH GENERATION ----- */
            if (r.Solved)
            {
                r.Path = SearchHelper.GetPathFromStart(current, Paths, Problem.Start);
            }

            return(r);
        }
コード例 #2
0
        public SearchResults Search(HexagonalTileSearchProblem Problem)
        {
            SearchResults r = new SearchResults();

            if (Problem == null)
            {
                return(r);
            }

            Dictionary <MapTile, MapTile> Paths = new Dictionary <MapTile, MapTile>();

            Dictionary <MapTile, bool> Explored = new Dictionary <MapTile, bool>((int)Problem.SearchSpace.Size);

            foreach (MapTile mt in Problem.SearchSpace.XYTiles())
            {
                Explored.Add(mt, false);
            }

            hSortedList <double, MapTile> Available = new hSortedList <double, MapTile>();

            Available.Add(0, Problem.Start);

            /* ***** SEARCH ************ */

            /* In the best first search approach, each node is evaluated based
             * on an estimation of its distance from the goal. In a fashion similar
             * to the A* search, if a node has been view before, or is part of a path,
             * costs are compared and the cheaper used. */
            MapTile  current    = null;
            DateTime start_time = DateTime.Now;

            while (Available.Count != 0)
            {
                if (Available.Count > r.SpaceComplexity)
                {
                    r.SpaceComplexity = Available.Count;
                }

                current = Available.Pop();
                r.TimeComplexity++;

                Explored[current] = true;

                //If we have recieved the destination, we have completed the search.
                if (current == Problem.Goal)
                {
                    r.Solved = true;
                    break;
                }

                //If we have not found the destination, catalog the available operations
                //from this mapTile.
                foreach (MapTile mt in current.GetNeighbours())
                {
                    if (Explored[mt] == false)
                    {
                        if (!Paths.ContainsKey(mt))
                        {
                            Paths[mt] = current;
                            Available.Add(
                                Heuristic.Calculate(mt, Problem.Goal),
                                mt);
                        }
                        else
                        {
                            int     old_cost  = SearchHelper.GetPathLengthFromStart(mt, Paths, Problem.Start);
                            MapTile oldParent = Paths[mt];
                            Paths[mt] = current;
                            int new_cost = SearchHelper.GetPathLengthFromStart(mt, Paths, Problem.Start);
                            //If the new cost to the tile is more than our previous
                            //path to this tile, we want to keep our previous parent.
                            if (new_cost > old_cost)
                            {
                                Paths[mt] = oldParent;
                            }
                            else
                            {
                                Available.Add(
                                    Heuristic.Calculate(mt, Problem.Goal),
                                    mt);
                            }
                        }
                    }
                }
            }

            DateTime end_time = DateTime.Now;

            r.TimeInMilliseconds = (int)(end_time - start_time).TotalMilliseconds;

            /* Backtrack for find path */
            if (r.Solved)
            {
                r.Path = SearchHelper.GetPathFromStart(current, Paths, Problem.Start);
            }

            return(r);
        }