コード例 #1
0
ファイル: DFS.cs プロジェクト: LironAvr/AI-Searching
        /// <summary>
        /// Solves the Searchable using DFS algorithm - Finds a path from the InitialState to the GoalState
        /// </summary>
        /// <param name="searchable"></param>
        /// <returns> Solution </returns>
        public override Solution Solve(ISearchable searchable)
        {
            clear();
            m_openListStates.Clear();
            m_stopWatch.Restart();
            Solution solution = new Solution();
            AState   current  = searchable.getInitialState();
            AState   goal     = searchable.getGoalState();

            m_closedList.Add(current.getState(), current);
            while (!goal.Equals(current))
            {
                List <AState> successors = searchable.getAllSuccessors(current);
                addToOpenList(successors);
                //Pops the next state to evaluate - Skips states that where already evaluated (exist in the closedList)
                while (m_openListStates.Count > 0 && m_closedList.ContainsKey(current.getState()))
                {
                    current = m_openListStates.Pop();
                }
                //Adds the current state (thats currently being evaluated) to the closed list so that it wont be evaluated again
                if (!m_closedList.ContainsKey(current.getState()))
                {
                    m_closedList.Add(current.getState(), current);
                    m_countGeneratedNodes++;
                }
            } //While loop is done - means the current state is the goal state

            solution = searchable.createSolution(current);
            m_stopWatch.Stop();
            return(solution);
        }
コード例 #2
0
 /// <summary>
 /// comper the state to other state
 /// </summary>
 /// <param name="other"> state to compare</param>
 /// <returns> 0 if equal -1 otherwise</returns>
 public override int CompareTo(AState other)
 {
     if (this.Equals(other))
     {
         return(0);
     }
     return(-1);
 }
コード例 #3
0
 /// <summary>
 /// check if the state equal to other state
 /// </summary>
 /// <param name="obj"> state to compare </param>
 /// <returns> true if equal false otherwise</returns>
 public override bool Equals(AState obj)
 {
     if (obj is MazeState)
     {
         return(this.position.Equals(((MazeState)obj).position));
     }
     return(false);
 }
コード例 #4
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="maze3d"></param>
        public SearchableMaze3D(AMaze maze3d)
        {
            m_maze3d = (Maze3d)maze3d;
            Position3D statrPosition = (Position3D)maze3d.getStartPosition();

            m_initialState = new MazeState(null, statrPosition.Col, statrPosition.Row, statrPosition.Level);
            Position3D goalPosition = (Position3D)maze3d.getGoalPosition();

            m_goalState = new MazeState(null, goalPosition.Col, goalPosition.Row, goalPosition.Level);
        }
コード例 #5
0
        /// <summary>
        /// Backtracking a solution from a gives state (Using parent states)
        /// </summary>
        /// <param name="end"></param>
        /// <returns> Solution </returns>
        public Solution createSolution(AState end)
        {
            Solution solution = new Solution();
            AState   current  = end;

            while (null != current)
            {
                solution.addState(current);
                current = current.getParentState();
            }
            solution.reverese();
            return(solution);
        }
コード例 #6
0
        /// <summary>
        /// Returns a List containing all the possible (valid) successors of a gives AState
        /// </summary>
        /// <param name="state"></param>
        /// <returns> List of successors  </returns>
        public List <AState> getAllSuccessors(AState state)
        {
            List <AState> successors = new List <AState>();
            MazeState     mState     = (MazeState)state;
            int           col        = mState.getX();
            int           row        = mState.getY();
            int           floor      = mState.getZ();

            //Right (Col ++)
            if (col + 1 < m_maze3d.getWidth() && m_maze3d.isPath(col + 1, row, floor))
            {
                successors.Add(new MazeState(state, col + 1, row, floor));
            }
            //Left (Col --)
            if (col - 1 >= 0 && m_maze3d.isPath(col - 1, row, floor))
            {
                successors.Add(new MazeState(state, col - 1, row, floor));
            }
            //Up (Row ++)
            if (row + 1 < m_maze3d.getHeight() && m_maze3d.isPath(col, row + 1, floor))
            {
                successors.Add(new MazeState(state, col, row + 1, floor));
            }
            //Down (Row --)
            if (row - 1 >= 0 && m_maze3d.isPath(col, row - 1, floor))
            {
                successors.Add(new MazeState(state, col, row - 1, floor));
            }
            //Ascend (Floor ++)
            if (floor + 1 < m_maze3d.getLevels() && m_maze3d.isPath(col, row, floor + 1))
            {
                successors.Add(new MazeState(state, col, row, floor + 1));
            }
            //Descend (Floor --)
            if (floor - 1 >= 0 && m_maze3d.isPath(col, row, floor - 1))
            {
                successors.Add(new MazeState(state, col, row, floor - 1));
            }
            return(successors);
        }
コード例 #7
0
        /// <summary>
        /// solving searchable problem acording to dfs algorithm
        /// </summary>
        /// <param name="searchDomain"> searcheble problem </param>
        /// <returns> solution to the problem </returns>
        public override Solution Solve(ISearchable searchDomain)
        {
            StartMeasureTime();
            Solution sol = new Solution();

            AState goal  = searchDomain.GetGoalState();
            AState state = searchDomain.GetStartState();
            IEnumerable <AState> stateSuccessors;

            stack.Push(state);

            while (stack.Count > 0)
            {
                state = stack.Pop();

                if (state.Equals(goal))
                {
                    sol = makeSolotion(state);
                    break;
                }

                else
                {
                    stateSuccessors = searchDomain.GetAllSuccessors(state);

                    foreach (AState successor in stateSuccessors)
                    {
                        stack.Push(successor);
                        m_countGeneratedNodes++;
                    }
                }
            }
            searchDomain.recoverProblem();
            StopMeasureTime();
            return(sol);
        }
コード例 #8
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="parentState"></param>
 public AState(AState parentState)
 {
     m_parentState = parentState;
 }
コード例 #9
0
 /// <summary>
 /// Adds a INode to the SortedList.
 /// </summary>
 /// <param name="sortedList">SortedList to add the node to.</param>
 /// <param name="node">Node to add to the sortedList.</param>
 internal static void Add(this SortedList <int, AState> sortedList, AState state)
 {
     sortedList.Add(state.TotalCost, state);
 }
コード例 #10
0
 /// <summary>
 /// constractor
 /// </summary>
 /// <param name="pos"> position of the new state</param>
 /// <param name="parentState"> the new state parent</param>
 public MazeState(Position pos, AState parentState) : base(parentState)
 {
     position = pos;
 }
コード例 #11
0
ファイル: MazeState.cs プロジェクト: LironAvr/AI-Searching
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="parentState"></param>
 /// <param name="pointX"></param>
 /// <param name="pointY"></param>
 /// <param name="pointZ"></param>
 public MazeState(AState parentState, int pointX, int pointY, int pointZ)
     : base(parentState)
 {
     m_state    = "(" + pointX + "," + pointY + "," + pointZ + ")";
     m_position = new Position3D(pointZ, pointY, pointX);
 }
コード例 #12
0
ファイル: Solution.cs プロジェクト: adi-ronen/ATP-Project
 /// <summary>
 /// add a new state
 /// </summary>
 /// <param name="state">the new state to add</param>
 public void AddState(AState state)
 {
     m_solutionPath.Add(state);
 }
コード例 #13
0
 /// <summary>
 /// Adds a state to the Solution
 /// </summary>
 /// <param name="state"></param>
 public void addState(AState state)
 {
     m_solution.Add(state);
 }