‫ﺑﺎﺳﻤﻪ ﺗﻌﺎﻟ‬
‫ﻫﻮش ﻣﺼﻨﻮﻋ‬
‫‪Artificial Intelligence‬‬
‫داﻧﺸ ﺪهی ﻣﻬﻨﺪﺳ ﮐﺎﻣﭙﯿﻮﺗﺮ‬
‫ﻣﺪرس‪ :‬دﮐﺘﺮ ﺳﻠﯿﻤﺎﻧ‬
‫ﻣﻮﻋﺪ ﺗﺤﻮﯾﻞ‪ ١٣ :‬اﺳﻔﻨﺪ ‪١٣٩١‬‬
‫ﺗﻤﺮﯾﻦ ﻋﻤﻠ ‐ ﺷﻤﺎرهی ‪١‬‬
‫• ﺑﻪ ازای ﻫﺮ روز ﺗﺎﺧﯿﺮ در ﺗﺤﻮﯾﻞ ﺗﻤﺮﯾﻦ )ﺣﺪاﮐﺜﺮ ‪ ٣‬روز( ‪ ١٠٪‬از ﻧﻤﺮهی آن ﮐﺎﺳﺘﻪ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫• ﺟﻮاب ﺗﻤﺮﯾﻦﻫﺎی ﻋﻤﻠ ﺧﻮد را ﻣ ﺑﺎﯾﺴﺖ از ﻃﺮﯾﻖ اﯾﻤﯿﻞ ﺑﺎ ﻣﻮﺿﻮع ]‪HW1-[STUDENT-ID‬‬
‫ﺑﻪ ‪ [email protected]‬ارﺳﺎل ﮐﻨﯿﺪ‪.‬‬
‫• اﯾﻦ ﺗﻤﺮﯾﻦ در ﻣﺠﻤﻮع ‪ ١٣۵‬ﻧﻤﺮه )‪ ۶۵‬ﻧﻤﺮه ﺗﺌﻮری ‪ ٧٠‬ﻧﻤﺮه ﻋﻤﻠ ( اﺳﺖ‪ ،‬ﻧﻤﺮهی اﻣﺘﯿﺎزی آن ﻓﻘﻂ ﺑﺮای ﻫﻤﯿﻦ ﺗﻤﺮﯾﻦ‬
‫اﺳﺖ و اﺛﺮ ﻣﺜﺒﺘ در ﺳﺎﯾﺮ ﻗﺴﻤﺖﻫﺎی درس ﻧﺪارد‪.‬‬
‫از ‪ ٢‬زﺑﺎن ‪ Python‬ﯾﺎ ‪ Java‬ﺑﺎﺷﻨﺪ‪ .‬دﻗﺖ ﮐﻨﯿﺪ ﮐﻪ ﻓﻘﻂ ﻓﺎﯾﻞﻫﺎی ﺧﻮاﺳﺘﻪ ﺷﺪه را‬
‫• ﺑﺮﻧﺎﻣﻪﻫﺎی ارﺳﺎﻟ ﻣ ﺑﺎﯾﺴﺖ ﺑﻪ ﯾ‬
‫ارﺳﺎل ﮐﻨﯿﺪ‪.‬‬
‫• در ﺻﻮرت ﻣﺸﺎﻫﺪهی ﺗﻘﻠﺐ ﺑﺮای ﻫﺮ دو ﻃﺮف ﻧﻤﺮهی ‪ ٠‬در اﯾﻦ ﺗﻤﺮﯾﻦ ﻣﻨﻈﻮر ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬
‫• ﺣﺘﻤﺎ در ﺟﻠﺴﻪی ﺣﻞﺗﻤﺮﯾﻦ اﯾﻦ ﺗﻤﺮﯾﻦ ﺑﺮای رﻓ اﺑﻬﺎم ﺷﺮﮐﺖ ﮐﻨﯿﺪ!‬
‫ﺷ ﻞ ‪ :١‬ﺑﺎزی ﭘ‬
‫ﺗﻌﺮﯾﻒ‬
‫در اﯾﻦ ﭘﺮوژه ﺷﻤﺎ ﺑﺮای ﯾ‬
‫ﻫﺮ ﺣﺮﮐﺖ در ﯾ‬
‫ﻣﻦ ﺑﺎ ﮔﺮاﻓﯿ‬
‫ﭘﺎﯾﺘﻮن‬
‫ﻋﺎﻣﻞ ‪ PacMan‬ﺑﺎﯾﺪ ﺑﺮﻧﺎﻣﻪ ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬
‫واﺣﺪ زﻣﺎﻧ اﻧﺠﺎم ﻣ ﺷﻮد‪ .‬ﭘ‬
‫ﻣﻦ ﻧﻤ ﺗﻮاﻧﺪ ﺑﻪ ﺧﺎﻧﻪﻫﺎﯾﯽ ﮐﻪ دﯾﻮار ﻗﺮار دارد ﺑﺮود‪ .‬ﺧﻮردن ﻫﺮ ﻏﺬا ‪۵٠٠+‬‬
‫اﻣﺘﯿﺎز دارد و ﻫﺮ واﺣﺪ زﻣﺎﻧ ﮐﻪ ﺑ ﺬرد ‐‪ ١‬اﻣﺘﯿﺎز ﺑﻪ ﺷﻤﺎ اﺿﺎﻓﻪ ﻣ ﺷﻮد‪ .‬زﻧﺪه ﺑﻮدن ﺷﻤﺎ در اﻧﺘﻬﺎ ﻫﻢ ‪ ١٠+‬اﻣﺘﯿﺎز دارد! ﺑﺮای‬
‫ﺷﺮوع ﮐﺎﻓﯿﺴﺖ ‪ Main.java‬را اﺟﺮا ﮐﻨﯿﺪ‪.‬‬
‫‪١‬‬
‫‪١‬‬
‫ﺟﺴﺘﺠﻮی ﻣ ﺎﻧ‬
‫‪ ٣٠) ١‬ﻧﻤﺮه ﻫﺮ ﻣﻮرد ‪ ١٠‬ﻧﻤﺮه( در اﯾﻦ ﻣﺴﺌﻠﻪ ﻫﺪف رﺳﯿﺪن ﺑﻪ ﯾ‬
‫ﺧﺎﻧﻪی ﻣﺸﺨﺺ اﺳﺖ ﮐﻪ ﻏﺬا در آن وﺟﻮد دارد‪ .‬در اﯾﻦ‬
‫ﺳﻮال ﺷﻤﺎ ﺑﺎﯾﺪ ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ﻓﺎﯾﻞ ‪ Search.java‬را ﭘﯿﺎده ﺳﺎزی ﮐﻨﯿﺪ‪ .‬اﯾﻦ ﺗﻮاﺑﻊ ﺟﺴﺘﺠﻮ‪ ،‬ﻫﻤ‬
‫ﯾ‬
‫‪SearchProblem‬‬
‫را ﺑﻪ ﻋﻨﻮان ورودی درﯾﺎﻓﺖ ﻣ ﮐﻨﻨﺪ‪ .‬ﺷﻤﺎ ﺑﺎﯾﺪ دﻧﺒﺎﻟﻪای از ﺣﺮﮐﺎت را اراﺋﻪ دﻫﯿﺪ ﮐﻪ از وﺿﻌﯿﺖ اوﻟﯿﻪ ﺑﻪ وﺿﻌﯿﺖ ﻫﺪف ﺑﺮﺳﺪ‪.‬‬
‫ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ ﺟﺴﺘﺠﻮی ﺧﻮد را ﺑﻪ ﺻﻮرت ‪ Graph Search‬اﻧﺠﺎم دﻫﯿﺪ‪.‬‬
‫‪ State‬ﯾ‬
‫واﺳﻂ ‪ ٢‬اﺳﺖ ﮐﻪ ﺗﻮاﺑﻊ زﯾﺮ را ﭘﺸﺘﯿﺒﺎﻧ ﻣ ﮐﻨﺪ‪.‬‬
‫; ) ( ‪1 p u b l i c i n t getID‬‬
‫; ) ( ‪2 public Point getPos‬‬
‫ﺷ ﻞ ‪ :٢‬ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ﯾ‬
‫وﺿﻌﯿﺖ‬
‫ﮐﻪ ﺗﺎﺑﻊ ‪ ،١‬ﻋﺪدی ﯾ ﺘﺎ ﺑﻪ ازای ﻫﺮ وﺿﻌﯿﺖ ﺑﺮ ﻣ ﮔﺮداﻧﺪ‪ .‬ﯾﻌﻨ ‪ id‬دو وﺿﻌﯿﺖ ﯾ ﺴﺎن اﺳﺖ اﮔﺮ و ﻓﻘﻂ اﮔﺮ ﺧﻮد دو وﺿﻌﯿﺖ‬
‫ﯾ ﺴﺎن ﺑﺎﺷﻨﺪ‪ .‬ﺗﺎﺑﻊ ‪ ،٢‬ﻣﺨﺘﺼﺎت ﭘ‬
‫ﻣﻦ را ﺑﺮ ﻣ ﮔﺮداﻧﺪ‪.‬‬
‫راﻫﻨﻤﺎﯾﯽ‪ :‬ﮐﺎرﻫﺎی ﺧﻮد را ﺑﺎ ‪ id‬ﯾ‬
‫‪ state‬اﻧﺠﺎم دﻫﯿﺪ!‬
‫‪ SearchProblem‬ﯾ‬
‫ﮐﻼس اﻧﺘﺰاﻋ اﺳﺖ‪ ،‬ﮐﻪ ﺗﻮاﺑﻊ زﯾﺮ را ﭘﺸﺘﯿﺒﺎﻧ ﻣ ﮐﻨﺪ‪.‬‬
‫; )( ‪1 public abstract State getStartState‬‬
‫; ) ‪2 public a b s t r a c t boolean isGoalState ( State s t a t e‬‬
‫; ) ‪3 p u b l i c a b s t r a c t A r r a y L i s t <T r i p l e > g e t S u c c e s s o r s ( S t a t e s t a t e‬‬
‫ﺷ ﻞ ‪ :٣‬ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ﯾ‬
‫ﺗﺎﺑﻊ ‪ ،١‬وﺿﻌﯿﺖ اوﻟﯿﻪ را ﺑﺮ ﻣ ﮔﺮداﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ ،٢‬ﻫﺪف ﺑﻮدن ﯾ‬
‫ﻣﺴﺌﻠﻪی ﺟﺴﺘﺠﻮ‬
‫وﺿﻌﯿﺖ را ﻧﺸﺎن ﻣ دﻫﺪ‪ .‬ﺗﺎﺑﻊ ‪ ،٣‬در ورودی ﯾ‬
‫ﻣ ﮔﯿﺮد و ﺗﻤﺎم وﺿﻌﯿﺖﻫﺎﯾﯽ ﮐﻪ از اﯾﻦ راس ﻣ ﺗﻮان ﺧﺎرج ﺷﺪ را ﺑﺮ ﻣ ﮔﺮداﻧﺪ‪ .‬اﯾﻦ ﺧﺮوﺟ ﺑﻪ ﺻﻮرت ﯾ‬
‫ﯾ‬
‫وﺿﻌﯿﺖ‬
‫‪ Triple‬اﺳﺖ ﮐﻪ‬
‫ﺳﻪﺗﺎﯾﯽ )وﺿﻌﯿﺖ ﺟﺪﯾﺪ‪ ،‬ﺣﺮﮐﺖ ]ﺟﻬﺖ[ ﺑﺮای رﺳﯿﺪن ﺑﻪ اﯾﻦ وﺿﻌﯿﺖ ﺟﺪﯾﺪ و ﻫﺰﯾﻨﻪی ﻋﻤﻞ( اﺳﺖ‪.‬‬
‫راﻫﻨﻤﺎﯾﯽ‪ :‬ﺗﺎ ﺣﺪ اﻣ ﺎن وارد ﺟﺰﺋﯿﺎت ﭘﯿﺎدهﺳﺎزی ﯾ‬
‫‪ SearchProblem‬ﻧﺸﻮﯾﺪ و ﺑﻪ ﺻﻮرت ﮐﺎﻣﻠﻦ اﻧﺘﺰاﻋ ﺑﺎ آن ﮐﺎر ﮐﻨﯿﺪ!‬
‫راﻫﻨﻤﺎﯾﯽ ‪ :٢‬ﺑﺮای اﻃﻼﻋﺎت ﺑﯿﺸﺘﺮ ﺑﻪ ‪ Search.java‬و ‪ SearchProblem.java‬و ‪ Triple.java‬ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ‪.‬‬
‫در ﮐﻠﯿﻪ اﻟ ﻮرﯾﺘﻢﻫﺎی زﯾﺮ ﺗﺎﺑﻌ را ﭘﯿﺎدهﺳﺎزی ﻣ ﮐﻨﯿﺪ ﮐﻪ ﯾ‬
‫ﯾ‬
‫دﻧﺒﺎﻟﻪ از ﺣﺮﮐﺎت‪ ،‬ﮐﻪ ﻫﺮ ﺣﺮﮐﺖ ﯾ‬
‫‪ SearchProblem‬را ﺑﻪ ﻋﻨﻮان ورودی درﯾﺎﻓﺖ ﻣ ﮐﻨﻨﺪ و‬
‫ﺟﻬﺖ اﺳﺖ ]>‪ [ArrayList<Direction‬ﺑﺎز ﻣ ﮔﺮداﻧﺪ‪ .‬ﺑﻪ ﮔﻮﻧﻪای ﮐﻪ ﭘ‬
‫ﻣﻦ ﺑﺎ‬
‫دﻧﺒﺎل ﮐﺮدن اﯾﻦ ﺣﺮﮐﺎت ﺑﻪ ﺗﮏ ﻏﺬای ﻣﻮﺟﻮد در ﺻﻔﺤﻪ ﺑﺮﺳﺪ‪.‬‬
‫‪Search Problem‬‬
‫‪١ Positional‬‬
‫‪٢ Interface‬‬
‫‪٢‬‬
‫ﺟﺴﺘﺠﻮی ﻋﻤﻖ اول‬
١.١
.‫ ﺑﺎﯾﺪ ﭘﯿﺎدهﺳﺎزی ﮐﻨﯿﺪ‬Search.java ‫ را در ﻓﺎﯾﻞ‬depthFirstSearch ‫ ﺗﺎﺑﻊ‬٣
.‫ اﺟﺮا ﮐﻨﯿﺪ‬Main.java ‫ﺑﺎزی را ﺑﺎ ﭘﺎراﻣﺘﺮﻫﺎی ورودی زﯾﺮ در ﻓﺎﯾﻞ‬
1 p u b l i c s t a t i c S t r i n g mapName = ” t i n y M a z e ” ; / / t i n y M a z e , mediumMaze , bigMaze
2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . POSITIONAL ;
3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . DFS ;
4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . H n u l l ;
١-١ ‫ ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای‬:۴ ‫ﺷ ﻞ‬
‫ﺟﺴﺘﺠﻮی ﺳﻄ اول‬
٢.١
.‫ ﺑﺎﯾﺪ ﭘﯿﺎدهﺳﺎزی ﮐﻨﯿﺪ‬Search.java ‫ را در ﻓﺎﯾﻞ‬breadthFirstSearch ‫ ﺗﺎﺑﻊ‬۴
1 p u b l i c s t a t i c S t r i n g mapName = ” mediumMaze ” ; / / t i n y M a z e , mediumMaze , bigMaze
2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . POSITIONAL ;
3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . BFS ;
4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . H n u l l ;
٢-١ ‫ ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای‬:۵ ‫ﺷ ﻞ‬
‫اﻟﻒ ﺳﺘﺎره‬
٣.١
ManhatanHeuristic.java ‫ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﺑﺮای ﺷﻤﺎ در ﻓﺎﯾﻞ‬.‫ ﺑﺎﯾﺪ ﭘﯿﺎدهﺳﺎزی ﮐﻨﯿﺪ‬Search.java ‫ را در ﻓﺎﯾﻞ‬aStarSearch ‫ ﺗﺎﺑﻊ‬۵
‫ﻣﻦ از ﺧﺎﻧﻪی ﻫﺪف راﺑﻪ ﻋﻨﻮان ﺗﺎﺑﻊ‬
‫ی ﭘ‬manhatan ‫ ﻓﺎﺻﻠﻪی‬،‫وﺿﻌﯿﺖ‬
‫ﻣﺴﺌﻠﻪ و ﯾ‬
‫ ﺑﺎ ﮔﺮﻓﺘﻦ ﯾ‬.‫ﭘﯿﺎدهﺳﺎزی ﺷﺪه اﺳﺖ‬
.‫ ﺑﺮﻣ ﮔﺮداﻧﺪ‬۶ ‫اﺑﺘﮑﺎری ﻗﺎﺑﻞ ﻗﺒﻮل‬
1 p u b l i c s t a t i c S t r i n g mapName = ” bigMaze ” ; / / t i n y M a z e , mediumMaze , bigMaze
2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . POSITIONAL ;
3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . ASTAR ;
4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . H manhatan ;
٣-١ ‫ ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای‬:۶ ‫ﺷ ﻞ‬
٣ DFS
۴ BFS
۵ A*
۶ Admissible
Heuristic Function
٣
‫‪٢‬‬
‫ﺟﺴﺘﺠﻮی ﮔﻮﺷﻪﻫﺎ‬
‫‪ ٢۵) ٧‬ﻧﻤﺮه‪ ،‬ﻣﻮرد اول ‪ ١٠‬ﻧﻤﺮه‪ ،‬ﻣﻮرد دوم ‪ ١۵‬ﻧﻤﺮه( در اﯾﻦ ﻣﺴﺌﻠﻪ ﻫﺪف ﺧﻮردن ‪ ۴‬ﻏﺬا ﮐﻪ در ‪ ۴‬ﮔﻮﺷﻪی ﻧﻘﺸﻪ ﻗﺮار دارد‪ ،‬در‬
‫ﮐﻢﺗﺮﯾﻦ زﻣﺎن اﺳﺖ‪ .‬در اﺑﺘﺪا ﺷﻤﺎ ﻣ ﺎن ﻏﺬاﻫﺎ و ﭘ‬
‫‪١.٢‬‬
‫ﻣﻦ را در اﺧﺘﯿﺎر دارﯾﺪ‪.‬‬
‫ﻧﻤﺎﯾﺶ وﺿﻌﯿﺖ ﮐﻤﯿﻨﻪ‬
‫در اﯾﻦ ﻗﺴﻤﺖ ﺑﺎﯾﺪ ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ‪ CornersSearchProblem.java‬را ﮐﺎﻣﻞ ﮐﻨﯿﺪ و ﺳﭙﺲ ﺑﻪ وﺳﯿﻠﻪی ﺗﺎﺑﻊ ‪bfs‬ای ﮐﻪ در‬
‫ﺗﻤﺮﯾﻦ ‪ ١‬ﻧﻮﺷﺘﯿﺪ اﯾﻦ ﻣﺴﺌﻠﻪ را ﺣﻞ ﮐﻨﯿﺪ‪.‬‬
‫اﺑﺘﺪا ﺑﺎﯾﺪ ﻫﺮ وﺿﻌﯿﺖ ﺑﺎزی را ﺑﺎ ﮐﻼس ‪ CornersSearchState‬ﻧﻤﺎﯾﺶ دﻫﯿﺪ‪ .‬ﻧﻤﺎﯾﺶ وﺿﻌﯿﺖ ‪٨‬ی را اﻧﺘﺨﺎب ﮐﻨﯿﺪ ﮐﻪ ﻣﯿﻨﯿﻤﺎل‬
‫ﺑﺎﺷﺪ‪ .‬ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ ‪ getID‬ﺑﺎﯾﺪ ﻣﺎﻧﻨﺪ ﻗﺴﻤﺖ ‪ ،١‬ﯾ ﺘﺎ ﺑﺎﺷﺪ و ﺑﻪ ازای دو وﺿﻌﯿﺖ ﯾ ﺴﺎن‪ ،‬ﻣﻘﺪار ﺑﺮاﺑﺮ ﺑﺮﮔﺮداﻧﺪ‪ .‬ﺳﭙﺲ ﺑﺎﯾﺪ‬
‫ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ‪ CornersSearchProblem‬را ﭘﺮ ﮐﻨﯿﺪ‪.‬‬
‫راﻫﻨﻤﺎﯾﯽ‪ :‬ﺗﻮاﺑﻌ ﮐﻪ ﺑﺎﯾﺪ ﭘﯿﺎدهﺳﺎزی ﮐﻨﯿﺪ ﻫﻤﺎﻧﻨﺪ ﮐﺎری ﮐﻪ در ‪ PositionSearchProblem‬اﻧﺠﺎم داده ﺷﺪه اﺳﺖ‪.‬‬
‫راﻫﻨﻤﺎﯾﯽ ‪ :٢‬ﻓﻘﻂ ﺑﻪ ﻣ ﺎن ﭘ‬
‫ﻣﻦ و ﻣ ﺎن ‪ ۴‬ﻏﺬای اوﻟﯿﻪ ﺑﺮای ﺣﻞ ﻣﺴﺌﻠﻪ ﻧﯿﺎز دارﯾﺪ‪.‬‬
‫; ” ‪1 p u b l i c s t a t i c S t r i n g mapName = ” mediumCorners‬‬
‫;‪2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . CORNER‬‬
‫; ‪3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . BFS‬‬
‫; ‪4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . Game . H n u l l‬‬
‫ﺷ ﻞ ‪ :٧‬ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای ‪١-٢‬‬
‫‪٢.٢‬‬
‫ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﮔﻮﺷﻪای‬
‫در اﯾﻦ ﻗﺴﻤﺖ )ﺑﺎ ﻓﺮض ﺣﻞ ﺷﺪن ﻗﺴﻤﺖ ﻗﺒﻞ!( ﻓﻘﻂ ﺑﺎﯾﺪ ﮐﻼس ‪ CornersHeuristic‬را ﭘﺮ ﮐﻨﯿﺪ‪ .‬در اﯾﻦ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﮐﺎﻓﯿﺴﺖ‬
‫ﺑﻪ ازای ﯾ‬
‫‪ CornersSearchProblem‬و ﯾ‬
‫‪ ،CornersSearchState‬ﻣﻘﺪار ﺗﺎﺑﻊ اﺑﺘﮑﺎری را ﻣﺤﺎﺳﺒﻪ و ﺑﺎز ﮔﺮداﻧﯿﺪ‪.‬‬
‫ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ اﯾﻦ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﺑﺎﯾﺪ ﺣﺘﻤﻦ ‪ Admissible‬و ‪ Consistent‬ﺑﺎﺷﺪ‪ .‬در ﺻﻮرﺗ ﮐﻪ دو ﺷﺮط ﻓﻮق را ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪،‬‬
‫ﻧﻤﺮهای ﻧﻤ ﮔﯿﺮد‪ .‬ﻣﻌﯿﺎر ارزﯾﺎﺑﯽ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﺷﻤﺎ ﺗﻌﺪاد راسﻫﺎی ﮔﺴﺘﺮش داده ﺷﺪه اﺳﺖ‪ .‬ﮐﻪ ﺑﺮاﺑﺮ ﺑﺎ ﺗﻌﺪاد ﺑﺎرﻫﺎی ﻓﺮاﺧﻮاﻧ‬
‫ﺗﺎﺑﻊ ‪ getSuccessors‬اﺳﺖ‪ .‬ﺑﻪ ﺗﻮاﺑﻊ اﺑﺘﮑﺎری ﻏﯿﺮ ﺑﺪﯾﻬ و ﻗﺎﺑﻞﻗﺒﻮل و ﺳﺎزﮔﺎر‪ ۵ ،‬ﻧﻤﺮه ﺗﻌﻠﻖ ﻣ ﮔﯿﺮد‪ .‬اﮔﺮ ﮐﻤﺘﺮ از ‪١۶٠٠‬‬
‫راس را ﮔﺴﺘﺮش دﻫﺪ‪ ۵+ ،‬ﻧﻤﺮهی دﯾ ﺮ‪ ،‬و اﮔﺮ ﮐﻤﺘﺮ از ‪ ١٢٠٠‬راس را ﮔﺴﺘﺮش دﻫﺪ ‪ ۵+‬ﻧﻤﺮهی دﯾ ﺮ ﻣ ﮔﯿﺮد‪.‬‬
‫; ” ‪1 p u b l i c s t a t i c S t r i n g mapName = ” mediumCorners‬‬
‫;‪2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . CORNER‬‬
‫; ‪3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . ASTAR‬‬
‫; ‪4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . H CORNER‬‬
‫ﺷ ﻞ ‪ :٨‬ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای ‪٢-٢‬‬
‫‪Search Problem‬‬
‫‪٧ Corner‬‬
‫‪Representation‬‬
‫‪۴‬‬
‫‪٨ State‬‬
‫‪٣‬‬
‫ﺟﺴﺘﺠﻮی ﻏﺬاﻫﺎ‬
‫)‪ ٢٠‬ﻧﻤﺮه‪ ،‬ﻫﺮ ﻗﺴﻤﺖ ‪ ۵‬ﻧﻤﺮه( در اﯾﻦ ﻣﺴﺌﻠﻪ ﻫﺪف ﺧﻮردن ﺗﻤﺎﻣ ﻏﺬاﻫﺎ‪ ،‬در ﮐﻢﺗﺮﯾﻦ زﻣﺎن اﺳﺖ‪ .‬در اﺑﺘﺪا ﺷﻤﺎ ﻣ ﺎن ﻏﺬاﻫﺎ و‬
‫ﭘ‬
‫ﻣﻦ را در اﺧﺘﯿﺎر دارﯾﺪ‪.‬‬
‫; ” ‪1 p u b l i c s t a t i c S t r i n g mapName = ” t r i c k y S e a r c h‬‬
‫;‪2 p u b l i c s t a t i c S t r i n g s e a r c h P r o b l e m = Game . FOOD‬‬
‫; ‪3 p u b l i c s t a t i c S t r i n g s e a r c h A l g o r i t h m = Game . ASTAR‬‬
‫; ‪4 p u b l i c s t a t i c S t r i n g h e u r i s t i c F u n c t i o n = Game . H FOOD‬‬
‫ﺷ ﻞ ‪ :٩‬ﭘﺎراﻣﺘﺮﻫﺎی ورودی ﺑﺮای ‪٣‬‬
‫در اﯾﻦ ﺳﻮال ﮐﺎﻓﯿﺴﺖ ﮐﻼس ‪ FoodHeuristic.java‬را ﭘﯿﺎدهﺳﺎزی ﮐﻨﯿﺪ‪ .‬ﮐﻪ ﺑﺎ ﮔﺮﻓﺘﻦ ﯾ‬
‫ﯾ‬
‫ﻣﺴﺌﻠﻪ ‪ FoodSearchProblem‬و‬
‫وﺿﻌﯿﺖ ‪ FoodSearchState‬ﻣﻘﺪار ﺗﺎﺑﻊ اﺑﺘﮑﺎری را آن وﺿﻌﯿﺖ را ﺑﺮﻣ ﮔﺮداﻧﺪ‪.‬‬
‫; ) ( ‪1 p u b l i c i n t getID‬‬
‫; ) ( ‪2 public Point getPos‬‬
‫; ) ( ‪3 p u b l i c A r r a y L i s t <P o i n t > g e t F o o d s‬‬
‫; ) ( ‪4 p u b l i c A r r a y L i s t <P o i n t > g e t B a s e F o o d‬‬
‫ﺷ ﻞ ‪ :١٠‬ﺗﻮاﺑﻊ ﻣﻮﺟﻮد در ﯾ‬
‫وﺿﻌﯿﺖ ﻏﺬاﯾﯽ‬
‫ﺗﻮاﺑﻌ ﮐﻪ ﺑﺮای ﮐﺎر ﺑﺎ ‪ FoodSearchState‬ﻧﯿﺎز دارﯾﺪ‪ ،‬در زﯾﺮ آﻣﺪه اﺳﺖ‪ :‬ﺗﺎﺑﻊ ‪ ١‬و ‪ ٢‬ﻗﺒﻠﻦ ﺗﻮﺿﯿﺢ داده ﺷﺪه اﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ ٣‬ﻣ ﺎن‬
‫ﻏﺬاﻫﺎﯾﯽ ﮐﻪ ﻫﻨﻮز ﺧﻮرده ﻧﺸﺪه را ﺑﺮﻣ ﮔﺮداﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ ،۴‬ﻣ ﺎن اﺑﺘﺪاﯾﯽ ﺗﻤﺎم ﻏﺬاﻫﺎ را ﺑﺮﻣ ﮔﺮداﻧﺪ‪.‬‬
‫راﻫﻨﻤﺎﯾﯽ‪ :‬ﺷﻤﺎ ﺑﻪ ﺗﺎﺑﻊ ‪ ۴‬ﻧﯿﺎز ﻧﺨﻮاﻫﯿﺪ داﺷﺖ!‬
‫ﺑﺮای ﺗﺴﺖ در ﺣﺎﻟﺖ ﮐﻮﭼ‬
‫ﺗﺮ ﻣ ﺗﻮاﻧﯿﺪ از ﻧﻘﺸﻪی ‪ testSearch‬اﺳﺘﻔﺎده ﮐﻨﯿﺪ وﻟ ارزﯾﺎﺑﯽ ﺑﺮ روی ﻧﻘﺸﻪی ذﮐﺮ ﺷﺪه در ﺑﺎﻻ‬
‫اﺳﺖ‪ .‬ﺗﻮﺟﻪ ﮐﻨﯿﺪ ﮐﻪ اﯾﻦ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﺑﺎﯾﺪ ﺣﺘﻤﻦ ‪ Admissible‬و ‪ Consistent‬ﺑﺎﺷﺪ‪ .‬در ﺻﻮرﺗ ﮐﻪ دو ﺷﺮط ﻓﻮق را ﻧﺪاﺷﺘﻪ‬
‫ﺑﺎﺷﺪ‪ ،‬ﻧﻤﺮهای ﻧﻤ ﮔﯿﺮد‪ .‬ﻣﻌﯿﺎر ارزﯾﺎﺑﯽ ﺗﺎﺑﻊ اﺑﺘﮑﺎری ﺷﻤﺎ ﺗﻌﺪاد راسﻫﺎی ﮔﺴﺘﺮش داده ﺷﺪه اﺳﺖ‪ .‬ﮐﻪ ﺑﺮاﺑﺮ ﺑﺎ ﺗﻌﺪاد ﺑﺎرﻫﺎی‬
‫ﻓﺮاﺧﻮاﻧ ﺗﺎﺑﻊ ‪ getSuccessors‬اﺳﺖ‪ .‬ﺑﻪ ﺗﻮاﺑﻊ اﺑﺘﮑﺎری ﻏﯿﺮ ﺑﺪﯾﻬ و ﻗﺎﺑﻞﻗﺒﻮل و ﺳﺎزﮔﺎر ﮐﻪ ﮐﻤﺘﺮ از ‪ ١۵٠٠٠‬راس را ﮔﺴﺘﺮش‬
‫ﺑﺪﻫﺪ ‪ ۵‬ﻧﻤﺮه ﺗﻌﻠﻖ ﻣ ﮔﯿﺮد‪ .‬اﮔﺮ ﮐﻤﺘﺮ از ‪ ١٢٠٠٠‬راس‪ ۵+ ،‬ﻧﻤﺮهی دﯾ ﺮ‪ ،‬اﮔﺮ ﮐﻤﺘﺮ از ‪ ٩٠٠٠‬راس‪ ۵+ ،‬ﻧﻤﺮهی دﯾ ﺮ و اﮔﺮ‬
‫ﮐﻤﺘﺮ از ‪ ٧٠٠٠‬راس را ﮔﺴﺘﺮش دﻫﺪ ‪ ۵+‬ﻧﻤﺮهی دﯾ ﺮ ﻣ ﮔﯿﺮد‪.‬‬
‫‪۵‬‬
‫ﺗﻮﺿﯿﺤﺎت ﮐﻠ‬
‫ﮔﺮاﻓﯿ‬
‫ﮔﺮاﻓﯿ‬
‫ﺑﺎزی ﺑﻪ ﺻﻮرت ﻣﺒﺘﻨ ﺑﺮ ﻣﺘﻦ اﺳﺖ‪ .‬اﻣ ﺎن اﺟﺮای ﺑﺎزی ﺑﻪ ﺻﻮرت ﮔﺮاﻓﯿ‬
‫در ﭘﺎﯾﺘﻮن وﺟﻮد دارد وﻟ ﻣﺴﺘﻠﺰم ﻧﺼﺐ‬
‫ﺑﻮدن ﭘﺎﯾﺘﻮن ﺑﺮ روی ﮐﺎﻣﭙﯿﻮﺗﺮ ﺷﻤﺎ اﺳﺖ‪ .‬ﺗﻮﺟﻪ ﮐﻨﯿﺪ اﯾﻦ ﻗﺴﻤﺖ ﮐﺎﻣﻠﻦ اﺿﺎﻓﻪ اﺳﺖ‪ ،‬و ﺑﺮای زﯾﺒﺎﯾﯽ ﭘﺮوژه اﺳﺖ‪.‬‬
‫ﺑﺎ ﻓﻌﺎل ﺑﻮدن آﭘﺸﻦ ﮔﺮاﻓﯿ‬
‫ﯾﻌﻨ ; ‪ ،game.GRAPHIC ENABLE = true‬در اﻧﺘﻬﺎی اﺟﺮای ﺑﺮﻧﺎﻣﻪی ﺟﺎوا دﺳﺘﻮری ﺑﺮای‬
‫ﺷﻤﺎ ﻧﻮﺷﺘﻪ ﻣ ﺷﻮد ﮐﻪ ﺑﺎ اﺟﺮای آن در ﻓﻮﻟﺪر ﭘﺮوژه )ﺟﺎﯾﯽ ﮐﻪ ‪ src & python‬ﻗﺮار دارد( در ﺗﺮﻣﯿﻨﺎل‪ ،‬ﮔﺮاﻓﯿ‬
‫ﺑﺎزی ﺑﻪ ﺻﻮرت‬
‫زﯾﺒﺎ )ﻣﺎﻧﻨﺪ ﻋﮑﺲ اول ﺗﻤﺮﯾﻦ( اﺟﺮا ﻣ ﺷﻮد‪.‬‬
‫دﯾﺒﺎگ‬
‫ﺷ ﻞ ‪ :١١‬ﺑﺎزی ﭘ‬
‫ﻣﻦ ﻣﺒﺘﻨ ﺑﺮ ﻣﺘﻦ در ﺟﺎوا‪ ،‬ﻫﻤﺎن ﻧﻘﺸﻪ در ﺷ ﻞ اول ﺗﻤﺮﯾﻦ!‬
‫ﺑﺮای دﯾﺒﺎگ ﺑﺎزی راهﻫﺎی زﯾﺎدی وﺟﻮد دارد وﻟ ﺑﺎ ﻓﻌﺎل ﮐﺮدن آﭘﺸﻦ دﯾﺒﺎگ ﯾﻌﻨ ; ‪،game.DEBUG MODE = true‬‬
‫ﻣ ﺗﻮاﻧﯿﺪ ﺑﻪ ﺻﻮرت ﮔﺎم ﺑﻪ ﮔﺎم ﺑﺮﻧﺎﻣﻪ را اﺟﺮا ﮐﻨﯿﺪ و ﺑﻌﺪ از اﺟﺮای ﻫﺮ ﺣﻠﻘﻪی ﺑﺎزی ﺑﺎ وارد ﮐﺮدن ﻋﺪد ‪ ٠‬ﺑﻪ ﺣﻠﻘﻪی ﺑﻌﺪی ﺑﺎزی‬
‫ﻣ رود‪.‬‬
‫ﮐﭙﯽراﯾﺖ ﺗﻤﺮﯾﻦ‬
‫ﺻﻮرت ﺗﻤﺮﯾﻦ و ﻣﻮﺗﻮر ﮔﺮاﻓﯿ‬
‫آن از ﺗﻤﺮﯾﻦ درس ﻫﻮش آﻧﻼﯾﻦ داﻧﺸ ﺎه ﺑﺮﮐﻠ اﺳﺖ‪ .‬ﻃﺮاﺣ و ﭘﯿﺎدهﺳﺎزی ﺑﻪ زﺑﺎن ﺟﺎوا ﺑﺮای‬
‫داﻧﺸ ﺎه ﺷﺮﯾﻒ اﺳﺖ‪.‬‬
‫‪Licensing Information: Please do not distribute or publish solutions to this project. You are free to use and‬‬
‫‪extend these projects for educational purposes. The Pacman AI projects were developed at UC Berkeley,‬‬
‫‪primarily by John DeNero ([email protected]) and Dan Klein ([email protected]).‬‬
‫ﻧﮑﺎت دﯾ ﺮ‬
‫ﺑﺮ ﺧﻼف ﺻﻮرت ﺗﻤﺮﯾﻦ ﮐﻪ ﺑﺴﯿﺎر زﯾﺎد اﺳﺖ‪ ،‬ﺟﻮاب ﻫﺎ ﺑﺴﯿﺎر ﮐﻮﺗﺎه و ﻣﺨﺘﺼﺮ ﻫﺴﺘﻨﺪ‪.‬‬
‫اﻣ ﺎن ﺗﺤﻮﯾﻞ ﺗﻤﺮﯾﻦ ﺑﻪ زﺑﺎن ﭘﺎﯾﺘﻮن ﻧﯿﺰ وﺟﻮد دارد ﺑﺮای اﻃﻼﻋﺎت ﺑﯿﺸﺘﺮ ﺑﻪ دﺳﺘﯿﺎر ﻣﺮﺑﻮﻃﻪی اﯾﻦ ﺗﻤﺮﯾﻦ )ﺑﻬﺮوز رﺑﯿﻌ ( ﻣﺮاﺟﻌﻪ‬
‫ﮐﻨﯿﺪ‪ .‬در ﺻﻮرت ﻣﺸﺎﻫﺪهی ﻫﺮﮔﻮﻧﻪ ﺑﺎگ ﯾﺎ ﻣﺸ ﻞ ﺑﻪ اﯾﻤﯿﻞ ﺗﻤﺮﯾﻦ ﺑﺎ ﻣﻮﺿﻮع ‪ BUGS HW 1‬اﯾﻤﯿﻞ ارﺳﺎل ﮐﻨﯿﺪ ﯾﺎ ﺑﻪ دﺳﺘﯿﺎر‬
‫ﻣﺮﺑﻮﻃﻪی اﯾﻦ ﺗﻤﺮﯾﻦ ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ‪ ..................................................................................... .‬ﻣﻮﻓﻖ ﺑﺎﺷﯿﺪ‪.‬‬
‫‪۶‬‬