‫ﻞ‬ ‫ﻴ‬ ‫ﻠ‬ ‫ﺤ‬ ‫ﺗ‬ ‫ﻭ‬

‫ﺎ‬ ‫ﻫ‬

‫ﻪ‬ ‫ﻣ‬ ‫ﺪ‬ ‫ﻘ‬ ‫ﻣ‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬

‫ﺍ‬ ‫ﺍ‬ ‫ﺮ‬ ‫ﻃ‬ ‫ﺮ‬ ‫ﺑ‬ ‫ﯼ‬ ‫ﺍ‬

‫ﻲ‬ ‫ﺣ‬

‫ﻠ‬ ‫ﻋ‬

‫ﻪ‬

‫ﻟ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﻧ‬

‫ﺍ‬

‫ﻲ‬
 ‫ﺎ‬ ‫ﻄ‬

‫ﻣ‬ ‫ﺖ‬ ‫ﺳ‬

‫ﺐ‬

‫ﻟ‬

‫ﺮ‬ ‫ﻬ‬ ‫ﻓ‬

‫‪١‬‬

‫ﺭ‬ ‫ﺎ‬ ‫ﺘ‬ ‫ﻔ‬ ‫ﮔ‬ ‫ﺶ‬ ‫ﻴ‬ ‫ﭘ‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫‪٢‬‬ ‫‪۱‬‬

‫ﻱ‬

‫ﺭ‬ ‫ﻭ‬ ‫ﺁ‬ ‫ﺩ‬ ‫ﺎ‬ ‫ﻳ‬

‫‪-‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫ﻣﺮﻭﺭﯼ ﺑﺮ ﺭﻭﺷﻬﺎﯼ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﻭ ﭘﻴﭽﻴﺪﮔﯽ ﺁﻧﻬﺎ ‪٢ ......................................................................‬‬ ‫‪-١-١‬‬

‫ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺩﺭﺟﻲ )‪٢ ............................................................................. (Insertion Sort‬‬ ‫‪-١-١-١‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺍﺩﻏﺎﻣﻲ)‪٣ ................................................................... (Merge Sort‬‬ ‫‪-٢-١-١‬‬
‫ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺳﺮﻳﻊ)‪٤ ..................................................................................... (Quick Sort‬‬ ‫‪-٣-١-١‬‬
‫ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺗﻮﺩﻩ ﺍﯼ )‪٥ ................................................................................. (Heap Sort‬‬ ‫‪-٤-١-١‬‬

‫ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﻣﻴﻨﻴﻤﻢ ‪٦ .................................................................................................................‬‬ ‫‪-٢-١‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍﺷﺎﻝ)‪٦ ............................................................................................... (Kruskal‬‬ ‫‪-١-٢-١‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﭘﺮﻳﻢ )‪٧ ...................................................................................................... (Prim‬‬ ‫‪-٢-٢-١‬‬

‫ﭘﻴﻤﺎﻳﺶ ﻭ ﺟﺴﺘﺠﻮﯼ ﮔﺮﺍﻓﻬﺎ ‪٧ ........................................................................................................‬‬ ‫‪-٣-١‬‬

‫ﺟﺴﺘﺠﻮ ﻭ ﭘﻴﻤﺎﻳﺶ ﻋﻤﻘﯽ )‪٧ .................................................................................... (DFS‬‬ ‫‪-١-٣-١‬‬
‫ﺟﺴﺘﺠﻮ ﻭ ﭘﻴﻤﺎﻳﺶ ﺭﺩﻳﻔﯽ)‪٧ ..................................................................................... (BFS‬‬ ‫‪-٢-٣-١‬‬

‫‪٩‬‬ ‫‪۲‬‬

‫ﺎ‬ ‫ﻬ‬ ‫ﻤ‬ ‫ﺘ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬ ‫ﻞ‬ ‫ﻴ‬ ‫ﻠ‬ ‫ﺤ‬ ‫ﺗ‬
‫‪-‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫ﻧﻤﺎﺩﻫﺎﯼ ﻣﺠﺎﻧﺒﯽ ‪٩ .........................................................................................................................‬‬ ‫‪-۱-۲‬‬

‫ﺗﺤﻠﻴﻞ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ﺍﻟﮕﻮﺭﻳﺘﻢ‪١١ ..................................................................................................‬‬ ‫‪-۲-۲‬‬

‫ﺭﻭﺍﺑﻂ ﺑﺎﺯﮔﺸﺘﯽ ‪١٥ .........................................................................................................................‬‬ ‫‪-۳-۲‬‬

‫ﺭﻭﺍﺑﻂ ﺑﺎﺯﮔﺸﺘﯽ ﺩﺭﺟﻪ ‪١٥ ................................................................................................. ۱‬‬ ‫‪-۱-۳-۲‬‬
‫ﺭﻭﺍﺑﻂ ﺑﺎﺯﮔﺸﺘﯽ ﺩﺭﺟﻪ ‪) ۲‬ﻫﻤﮕﻦ( ‪١٥ .................................................................................‬‬ ‫‪-۲-۳-۲‬‬

‫ﻗﻀﻴﻪ ﺍﺻﻠﻲ)‪١٦ ............................................................................................... (Master Theorem‬‬ ‫‪-٤-٢‬‬

‫‪١‬‬ ‫‪٩‬‬ ‫‪۳‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫)‪(Greedy‬‬ ‫ﻪ‬ ‫ﻧ‬

‫ﺎ‬ ‫ﺼ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺣ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬

‫‪-‬‬

‫ﻣﺴﺄﻟﻪ ﻛﻮﻟﻪﭘﺸﺘﻲ ﺳﺎﺩﻩ ﻳﺎ ﮐﺴﺮﯼ )‪٢٠ .......................................................................... (Knapsack‬‬ ‫‪-١-٣‬‬

‫ﻣﺴﺌﻠﻪ ﺍﺩﻏﺎﻡ ﺩﻭﺩﻭﻳﻲ ﻭ ﺑﻬﻴﻨﻪ ﻓﺎﻳﻠﻬﺎ)ﻳﺎ ﺁﺭﺍﻳﻪ ﻫﺎﯼ ﻣﺮﺗﺐ( ‪٢٢ ...........................................................‬‬ ‫‪-٢-٣‬‬
 ‫ﻛﺪﻳﻨﮓ ‪٢٤ ..................................................................................................................... Huffman‬‬ ‫‪-٣-٣‬‬

‫ﺩﺭﺧﺖ ﭘﻮﺷﺎﻱ ﻣﻴﻨﻴﻤﻢ ‪٢٥ ...............................................................................................................‬‬ ‫‪-۴-۳‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍﺷﺎﻝ )‪٢٥ ............................................................................................. (kruskal‬‬ ‫‪-١-٤-٣‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ‪٢٧ ............................................................................................................... Prim‬‬ ‫‪-٢-٤-٣‬‬
‫ﻣﻘﺎﻳﺴﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Kruskal‬ﻭ ‪٢٧ .................................................................................Prim‬‬ ‫‪-٣-٤-٣‬‬
‫ﺗﻌﺪﺍﺩ ﺩﺭﺧﺘﻬﺎﯼ ﭘﻮﺷﺎﯼ ‪٢٧ ............................................................................................ Kn‬‬ ‫‪-٤-٤-٣‬‬

‫ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎﻱ ﻫﻢ ﻣﺒﺪﺍ ‪٣٣ ...................................................................................................‬‬ ‫‪-٥-٣‬‬

‫ﺍﻧﺘﺨﺎﺏ ﺑﻬﻴﻨﻪ ﻓﻌﺎﻟﻴﺘﻬﺎ )‪٣٧ .............................................................................. (Activity Selection‬‬ ‫‪-۶-۳‬‬

‫(‬ ‫)‬

‫‪٣‬‬ ‫‪٩‬‬ ‫‪۴‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫‪Divide & Conquer‬‬ ‫ﻞ‬ ‫ﺣ‬ ‫ﻭ‬ ‫ﻢ‬ ‫ﻴ‬ ‫ﺴ‬ ‫ﻘ‬ ‫ﺗ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬
‫‪-‬‬

‫ﻣﺤﺎﺳﺒﻪ ﻋﻨﺼﺮ ﮐﻤﻴﻨﻪ ﻭ ﺑﻴﺸﻴﻨﻪ ﻳﮏ ﺁﺭﺍﻳﻪ ‪٣٩ ...................................................................................‬‬ ‫‪-۱-۴‬‬

‫ﺿﺮﺏ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ﺑﻪ ﺭﻭﺵ ﺍﺳﺘﺮﺍﺳﻦ)‪٤١ ...................................................................... (Strassen‬‬ ‫‪-٢-٤‬‬

‫ﺗﻌﻴﻴﻦ ﻧﺰﺩﻳﻜﺘﺮﻳﻦ ﺯﻭﺝ ﻧﻘﺎﻁ ‪٤٢ ......................................................................................................‬‬ ‫‪-٣-٤‬‬

‫ﺗﻌﻴﻴﻦ ﻧﺰﺩﻳﻜﺘﺮﻳﻦ ﺯﻭﺝ ﻧﻘﺎﻁ ﺩﺭ ﻓﻀﺎﻱ ﻳﻚ ﺑﻌﺪﻱ ‪٤٢ ..........................................................‬‬ ‫‪-١-٣-٤‬‬
‫ﺗﻌﻴﻴﻦ ﻧﺰﺩﻳﻜﺘﺮﻳﻦ ﺯﻭﺝ ﻧﻘﺎﻁ ﺩﺭ ﻓﻀﺎﻱ ﺩﻭﺑﻌﺪﻱ ‪٤٣ .............................................................‬‬ ‫‪-٢-٣-٤‬‬

‫ﺗﻌﺎﺭﻳﻒ ﻭ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﭘﺎﻳﻪ ﺩﺭ ﻫﻨﺪﺳﻪ ﻣﺤﺎﺳﺒﺎﺗﯽ ‪٤٤ ....................................................................‬‬ ‫‪-۴-۴‬‬

‫ﺗﻮﻟﻴﺪ ﭘﻮﺵ ﻣﺤﺪﺏ )‪٤٧ ......................................................................................... (Convex Hull‬‬ ‫‪-٥-٤‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ‪٤٧ ......................................................................................................... Graham‬‬ ‫‪-١-٥-٤‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ‪٤٨ .......................................................................................................... Shamos‬‬ ‫‪-٢-٥-٤‬‬

‫‪۵‬‬

‫)‪(Dynamic Programming‬‬
‫‪٥‬‬ ‫‪٠‬‬

‫ﻪ‬ ‫ﻣ‬ ‫ﻧ‬

‫ﺎ‬ ‫ﻳ‬ ‫ﻮ‬ ‫ﭘ‬ ‫ﯼ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬ ‫ﺎ‬ ‫ﺮ‬ ‫ﺑ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬
‫‪-‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫ﻣﺴﺌﻠﻪ ﻛﻮﻟﻪﭘﺸﺘﻲ ‪٥١ ................................................................................................................ 0/1‬‬ ‫‪-١-٥‬‬

‫ﻣﺴﺌﻠﻪ ﻫﻤﻪ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ)‪٥٣ ..................................................................................... (APSP‬‬ ‫‪-٢-٥‬‬

‫ﻋﺪﺩ ﮐﺎﺗﻼﻥ )‪ (Catalan Number‬ﻭ ﻣﺴﺎﺋﻞ ﻭﺍﺑﺴﺘﻪ ‪٥٥ ....................................................................‬‬ ‫‪-٣-٥‬‬

‫ﺿﺮﺏ ﺯﻧﺠﻴﺮﻩﺍﻱ ﻭ ﺑﻬﻴﻨﻪ ﻣﺎﺗﺮﻳﺲﻫﺎ ‪٥٩ ..........................................................................................‬‬ ‫‪-۴-۵‬‬

‫ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﺑﻬﻴﻨﻪ ﭼﻨﺪ ﺿﻠﻌﯽ ﻣﺤﺪﺏ ‪٦١ .......................................................................................‬‬ ‫‪-٥-٥‬‬

‫ﻃﻮﻻﻧﻴﺘﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﮎ )‪٦٣ ....................................................................................... (LCS‬‬ ‫‪-٦-٥‬‬

‫ﻓﺮﻭﺷﻨﺪﻩ ﺩﻭﺭﻩ ﮔﺮﺩ ‪٦٦ ...................................................................................................................‬‬ ‫‪-٧-٥‬‬

‫‪٦‬‬ ‫‪٩‬‬ ‫‪۶‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫)‪(Backtracking‬‬ ‫ﺩ‬ ‫ﺮ‬ ‫ﮕ‬ ‫ﺒ‬ ‫ﻘ‬ ‫ﻋ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬
‫‪-‬‬
‫ﻣﻮﻟﺪ ﺗﺮﻛﻴﺒﺎﺕ‪٧٠ ............................................................................................................................‬‬ ‫‪-۱-۶‬‬

‫ﻣﺴﺌﻠﻪ ‪ n‬ﻭﺯﻳﺮ ‪٧٢ ............................................................................................................................‬‬ ‫‪-٢-٦‬‬

‫ﺗﻌﻴﻴﻦ ﻧﻘﺎﻁ ﺭﻭﻱ ﻣﺤﻮﺭ ‪x‬ﻫﺎ ﺍﺯ ﺭﻭﻱ ﻓﻮﺍﺻﻞ ﺁﻧﻬﺎ‪٧٤ .......................................................................‬‬ ‫‪-٣-٦‬‬

‫‪٧‬‬ ‫‪٧‬‬ ‫‪۷‬‬

‫)‪(Branch & Bound‬‬

‫ﺪ‬ ‫ﺪ‬

‫ﻧ‬

‫ﻳ‬ ‫ﺤ‬ ‫ﺗ‬ ‫ﻭ‬ ‫ﺏ‬ ‫ﺎ‬ ‫ﻌ‬ ‫ﺸ‬ ‫ﺍ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬
‫‪-‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫ﻓﺮﻭﺷﻨﺪﻩ ﺩﻭﺭﻩ ﮔﺮﺩ ‪٧٧ ...................................................................................................................‬‬ ‫‪-١-٧‬‬

‫ﺟﻤﻊ ﺯﻳﺮﻣﺠﻤﻮﻋﻪﻫﺎﻱ ﻳﻚ ﻣﺠﻤﻮﻋﻪ ‪٨١ .........................................................................................‬‬ ‫‪-٢-٧‬‬

‫‪٨‬‬ ‫‪٤‬‬ ‫‪۸‬‬

‫ﺪ‬

‫ﺕ‬

‫ﻣ‬ ‫ﯽ‬

‫ﺎ‬ ‫ﺒ‬ ‫ﺳ‬ ‫ﺎ‬ ‫ﺤ‬ ‫ﮔ‬ ‫ﻴ‬ ‫ﭽ‬ ‫ﻴ‬ ‫ﭘ‬
‫‪-‬‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬

‫ﻣﺴﺌﻠﻪ ﺗﺎ ﮐﺮﺩﻥ ﺧﻂ ﮐﺶ ‪٨٦ ...........................................................................................................‬‬ ‫‪-١-٨‬‬

‫ﻣﺴﺌﻠﻪ ﺍﻓﺮﺍﺯ )‪٨٦ ..................................................................................................... (PARTITION‬‬ ‫‪-٢-٨‬‬

‫‪٨‬‬ ‫‪٨‬‬

‫ﻣ‬ ‫ﻣ‬

‫ﻊ‬ ‫ﺟ‬ ‫ﻊ‬

‫ﺍ‬ ‫ﺮ‬ ‫ﻭ‬ ‫ﺑ‬ ‫ﺎ‬ ‫ﻨ‬

‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
 ‫ﺭ‬ ‫ﺎ‬ ‫ﺘ‬ ‫ﻔ‬ ‫ﮔ‬ ‫ﺶ‬ ‫ﻴ‬ ‫ﭘ‬

‫ﺩﺭﺱ ﻃﺮﺍﺣﯽ ﻭ ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﺍﺯ ﺩﺭﻭﺱ ﺍﺻﻠﯽ ﺩﻭﺭﻩ ﮐﺎﺭﺷﻨﺎﺳﯽ ﻣﻬﻨﺪﺳﯽ ﮐﺎﻣﭙﻴﻮﺗﺮ ﻭ ﻓﻦﺁﻭﺭﯼ ﺍﻃﻼﻋﺎﺕ ﻣﺤﺴﻮﺏ‬
‫ﻣﻴﺸﻮﺩ ﮐﻪ ﻧﻘﺶ ﺑﺴﻴﺎﺭ ﺍﺳﺎﺳﯽ ﺩﺭ ﺩﺭﮎ ﻭ ﻓﻬﻢ ﺩﺭﻭﺱ ﺩﻳﮕﺮ ﺭﺍ ﻧﻴﺰ ﺑﺎﺯﯼ ﻣﻴﮑﻨﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺩﺭ ﺩﻭﺭﻩ ﮐﺎﺭﺷﻨﺎﺳﯽ ﺍﺭﺷﺪ ﻧﻴـﺰ‬
‫ﺩﺭﻭﺳﯽ ﻣﺒﺘﻨﯽ ﺑﺮ ﺍﻳﻦ ﺩﺭﺱ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﮐﻪ ﺍﺯ ﺁﻥ ﺟﻤﻠﻪ ﻣﻴﺘﻮﺍﻥ ﺑـﻪ ﺩﺭﻭﺳـﯽ ﻧﻈﻴـﺮ ﻫﻨﺪﺳـﻪ ﻣﺤﺎﺳـﺒﺎﺗﯽ‪ ،‬ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎﯼ‬
‫ﭘﻴﺸﺮﻓﺘﻪ‪ ،‬ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﮊﻧﺘﻴﮏ ﻭ ﭘﺮﺩﺍﺯﺵ ﺗﮑـﺎﻣﻠﯽ‪ ،‬ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎﯼ ﻃﺮﺍﺣـﯽ ﻓﻴﺰﻳﮑـﯽ ﻣـﺪﺍﺭﺍﺕ ‪ VLSI‬ﻭ ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎﯼ‬
‫ﮔﺮﺍﻑ ﺍﺷﺎﺭﻩ ﮐﺮﺩ‪.‬‬
‫ﺩﺭ ﺍﻳﻦ ﮐﺘﺎﺏ ﺑﺎ ﺭﻭﺷﻬﺎﯼ ﻃﺮﺍﺣﯽ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﻭ ﺍﺻﻮﻝ ﺍﺳﺎﺳﯽ ﻭ ﻣﺒﻨـﺎﻳﻲ ﺗﺤﻠﻴـﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎ ﺁﺷـﻨﺎ ﻣﻴﺸـﻮﻳﻢ‪ .‬ﻫﻤﭽﻨـﻴﻦ‬
‫ﺟﻬﺖ ﺁﺷﻨﺎﻳﻲ ﺑﺎ ﺭﻭﺷﻬﺎﯼ ﻃﺮﺍﺣﯽ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﻣﺜﺎﻟﻬﺎﻳﻲ ﺍﺯ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﻫﻨﺪﺳﯽ ﻧﻴﺰ ﺑﻴﺎﻥ ﺷﺪﻩ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﻣﻴﺎﻥ ﻓﺼـﻮﻝ‬
‫ﮐﺘﺎﺏ ﺑﻪ ﺁﻧﻬﺎ ﺍﺷﺎﺭﻩ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺍﻳﻦ ﮐﺘﺎﺏ ﻣﺸـﺘﻤﻞ ﺑـﺮ ‪ ۸‬ﻓﺼـﻞ ﺍﺳـﺖ ﮐـﻪ ﺩﺭ ﻓﺼـﻞ ‪ ۱‬ﻳـﺎﺩﺁﻭﺭﯼ ﻣﺨﺘﺼـﺮﯼ ﺍﺯ ﺩﺭﺱ‬
‫ﺳﺎﺧﺘﻤﺎﻥ ﺩﺍﺩﻩ ﻫﺎ‪ ،‬ﺩﺭ ﻓﺼﻞ ‪ ۲‬ﺍﺻﻮﻝ ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎ ﻭ ﻧﻤﺎﺩﻫـﺎﯼ ﻣﺠـﺎﻧﺒﯽ‪ ،‬ﻓﺼـﻞ ‪ ۳‬ﺗـﺎ ‪ ۷‬ﻧﻴـﺰ ﺭﻭﺷـﻬﺎﯼ ﻃﺮﺍﺣـﯽ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﺭﺍ ﺩﺭ ﺑﺮ ﮔﺮﻓﺘﻪ ﺍﺳﺖ‪ .‬ﺩﺭ ﻓﺼﻞ ﺁﺧﺮ ﻧﻴﺰ ﻣﻘﺪﻣﻪ ﺍﯼ ﺑﺮ ﺗﺌﻮﺭﯼ ‪ NP‬ﺑﻴﺎﻥ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﺩﺭ ﺍﻳﻨﺠﺎ ﻻﺯﻡ ﻣﻴﺪﺍﻧﻢ ﮐﻪ ﺍﺯ ﺁﻗﺎﯼ ﻣﺤﻤﺪﺭﺿﺎ ﺑﺎﻗﺮﯼ ﻭ ﺧﺎﻧﻢ ﻓﺮﺯﺍﻧﻪ ﺻﺒﻮﺣﯽ ﮐـﻪ ﺩﺭ ﺟﻤـﻊ ﺁﻭﺭﯼ ﻭ ﺗﻨﻈـﻴﻢ ﺍﻭﻟﻴـﻪ ﮐﺘـﺎﺏ‬
‫ﺯﺣﻤﺎﺕ ﻓﺮﺍﻭﺍﻧﯽ ﺭﺍ ﻣﺘﺤﻤﻞ ﺷﺪﻧﺪ ﺗﺸﮑﺮ ﻧﻤﺎﻳﻢ‪.‬‬
 ‫‪۱‬‬

‫ﻱ‬

‫ﺭ‬ ‫ﻭ‬ ‫ﺁ‬ ‫ﺩ‬ ‫ﺎ‬ ‫ﻳ‬ ‫‪-‬‬

‫ﺗﻌﺮﻳﻒ ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﻫﺮ ﺩﺳﺘﻮﺍﻟﻌﻤﻠﯽ ﮐﻪ ﻣﺮﺍﺣﻞ ﻣﺨﺘﻠﻒ ﺍﻧﺠﺎﻡ ﮐﺎﺭﯼ ﺭﺍ ﺑﻪ ﺯﺑﺎﻥ ﺩﻗﻴﻖ ﻭ ﺑﺎ ﺟﺰﺋﻴﺎﺕ ﮐﺎﻓﯽ ﺑﻴـﺎﻥ ﻧﻤﺎﻳـﺪ ﺑـﻪ‬
‫ﻃﻮﺭﻳﮑﻪ ﺗﺮﺗﻴﺐ ﻣﺮﺍﺣﻞ ﻭ ﺷﺮﻁ ﺧﺎﺗﻤﻪ ﻋﻤﻠﻴﺎﺕ ﺩﺭ ﺁﻥ ﮐﺎﻣﻼﹰ ﻣﺸﺨﺺ ﺑﺎﺷﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﺎﻡ ﺩﺍﺭﺩ‪.‬‬

‫ﻣﻄﺎﻟﻌﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ ﺩﺭ ﺑﺮﮔﻴﺮﻧﺪﻩ ﻣﻮﺍﺭﺩ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫‪ -۱‬ﻃﺮﺍﺣﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫‪ -۲‬ﻣﻌﺘﺒﺮ ﺳﺎﺯﯼ ﻳﺎ ﺍﺛﺒﺎﺕ ﺩﺭﺳﺘﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫‪ -۳‬ﺑﻴﺎﻥ ﻳﺎ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫‪ -۴‬ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫ﮐﻪ ﺩﺭ ﺍﻳﻦ ﮐﺘﺎﺏ ﻣﺎ ﻣﻮﺍﺭﺩ ﺍﻭﻝ ﻭ ﭼﻬﺎﺭﻡ ﺭﺍ ﻣﻮﺭﺩ ﺑﺮﺭﺳﯽ ﻗﺮﺍﺭ ﻣﻴﺪﻫﻴﻢ‪.‬‬

‫‪١‬‬ ‫‪١‬‬

‫ﺎ‬ ‫ﻬ‬ ‫ﻧ‬ ‫ﺁ‬ ‫ﻭ‬ ‫ﯼ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬ ‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﻬ‬ ‫ﺷ‬ ‫ﻭ‬ ‫ﺭ‬ ‫ﺮ‬ ‫ﺑ‬ ‫ﯼ‬ ‫ﺭ‬ ‫ﻭ‬ ‫ﺮ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﯽ‬ ‫ﮔ‬ ‫ﺪ‬ ‫ﻴ‬ ‫ﭽ‬ ‫ﻴ‬ ‫ﭘ‬

‫‪Insertion Sort‬‬
‫(‬ ‫)‬

‫‪١‬‬ ‫‪١‬‬ ‫‪١‬‬

‫ﻱ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬

‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﻲ‬ ‫ﺟ‬ ‫ﺭ‬ ‫ﺩ‬

‫ﺩﺭ ﻣﺮﺣﻠﻪ ‪ j‬ﺍﻡ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﻋﻨﺎﺻﺮ ﺍﻭﻝ ﺗﺎ ‪ j-1‬ﺍﻡ ﺁﺭﺍﻳﻪ ﻣﺮﺗﺐ ﻫﺴﺘﻨﺪ ﻭ ﻋﻨﺼـﺮ ‪ j‬ﺍﻡ ﺩﺭ ﻋﻨﺎﺻـﺮ‬
‫ﻗﺒﻞ ﺍﺯ ﺧﻮﺩ ﺩﺭ ﻣﺤﻞ ﻣﻨﺎﺳﺐ ﺩﺭﺝ ﻣﻴﺸﻮﺩ‪ .‬ﺣﺎﻝ ﺑﻪ ﺍﺯﺍﯼ ‪ j‬ﺍﺯ ‪ ۲‬ﺗﺎ ‪ n‬ﺍﻳﻦ ﻋﻤﻞ ﺍﻧﺠﺎﻡ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﻣﺮﺣﻠﻪ ‪ x[1] :١‬ﺧﻮﺩﺵ ﺑﻪ ﺗﻨﻬﺎﻳﻲ ﺑﻄﻮﺭ ﺑﺪﻳﻬﻲ ﻣﺮﺗﺐ ﺍﺳﺖ‪.‬‬
‫ﻣﺮﺣﻠﻪ‪ x[2] :٢‬ﺭﺍ ﻳﺎ ﻗﺒﻞ ﺍﺯ ﻳﺎ ﺑﻌﺪ ﺍﺯ ]‪ x[1‬ﺩﺭﺝ ﻣﻲ ﮐﻨﻴﻢ ﻃﻮﺭﻳﮑﻪ ]‪ x[1‬ﻭ ]‪ x[2‬ﻣﺮﺗﺐ ﺷﻮﻧﺪ‪.‬‬
‫ﻣﺮﺣﻠﻪ‪ x[3] :٣‬ﺭﺍ ﺩﺭ ﻣﮑﺎﻥ ﺻﺤﻴﺢ ﺩﺭ ]‪ x[1‬ﻭ]‪ x[2‬ﺩﺭﺝ ﻣﻲ ﮐﻨﻴﻢ ﺑﻪ ﮔﻮﻧﻪ ﺍﻱ ﮐـﻪ ]‪ x[3],x[2],x[1‬ﻣﺮﺗـﺐ ﺷـﺪﻩ‬
‫ﺑﺎﺷﻨﺪ‪.‬‬
‫‪...‬‬
‫ﻣﺮﺣﻠﻪ‪ x[n] :n‬ﺭﺍ ﺩﺭ ﻣﮑﺎﻥ ﺻﺤﻴﺢ ﺧﻮﺩ ﺩﺭ ]‪ x[n-1] …,x[2], x[1‬ﺑﻪ ﮔﻮﻧﻪ ﺍﻱ ﺩﺭﺝ ﻣﻲ ﮐﻨﻴﻢ ﮐﻪ ﮐﻞ ﺁﺭﺍﻳﻪ ﻣﺮﺗﺐ‬
‫ﺷﺪﻩ ﺑﺎﺷﺪ‪.‬‬
‫‪٣‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫‪For j← 2 to n do‬‬
‫]‪k← x[j‬‬
‫‪i←j-1‬‬
‫‪while x[i]>k and i>0 do‬‬
‫]‪x[i+1] ← x[i‬‬
‫‪i ← i-1‬‬
‫‪repeat‬‬
‫‪x[i+1] ← k‬‬
‫‪repeat‬‬
‫ﺑﻪ ﺭﺍﺣﺘﯽ ﻗﺎﺑﻞ ﻣﻼﺣﻈﻪ ﺍﺳﺖ ﮐﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭﺿﻌﻴﺖ )ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﻧﺰﻭﻟﯽ ﺑﺎﺷﻨﺪ( ﺩﺭ ﻣﺮﺣﻠﻪ ‪j‬ﺍﻡ ﺑـﻪ ﺍﺯﺍﯼ‬
‫ﻋﻨﺼﺮ ‪ j‬ﺍﻡ ‪ j-1‬ﻣﻘﺎﻳﺴﻪ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﺪ ﻭ ﻟﺬﺍ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n2‬ﺧﻮﺍﻫﺪ ﺑـﻮﺩ!‪ .‬ﻭ ﺩﺭ ﺑﻬﺘـﺮﻳﻦ ﻭﺿـﻌﻴﺖ )ﻋﻨﺎﺻـﺮ‬
‫ﺁﺭﺍﻳﻪ ﺍﺯ ﻗﺒﻞ ﺻﻌﻮﺩﯼ ﺑﺎﺷﻨﺪ( ﺩﺭ ﻣﺮﺣﻠﻪ ‪ j‬ﺍﻡ ﺑﻪ ﺍﺯﺍﯼ ﻋﻨﺼﺮ ‪ j‬ﺍﻡ ﻳﮏ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻋﻨﺼﺮ ‪ j-1‬ﺍﻡ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﺪ ﻭ ﻟﺬﺍ ﺩﺍﺭﺍﯼ‬
‫ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻄﻮﺭ ﻣﺘﻮﺳﻂ ﻧﻴﺰ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n2‬ﺧﻮﺍﻫﺪ ﺑـﻮﺩ!‪ .‬ﻫﻤﭽﻨـﻴﻦ ﺍﺯ‬
‫ﻟﺤﺎﻅ ﻣﺼﺮﻑ ﺣﺎﻓﻈﻪ ﮐﻤﮑﯽ ﻧﻴﺰ ﭼﻮﻥ ﺁﺭﺍﻳﻪ ﺑﺪﻭﻥ ﻧﻴﺎﺯ ﺑﻪ ﺣﺎﻓﻈﻪ ﮐﻤﮑﯽ ﻣﺮﺗـﺐ ﻣﻴﺸـﻮﻧﺪ ﻟـﺬﺍ ﻣﻴـﺰﺍﻥ ﻣﺼـﺮﻑ ﺣﺎﻓﻈـﻪ‬
‫ﮐﻤﮑﯽ ﺑﺮﺍﺑﺮ ﺑﺎ )‪ O(1‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺩﺭﺟﯽ ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺻﻮﺭﺕ ﺩﻳﮕﺮﯼ ﺑﺎﺯﻧﻮﻳﺴﯽ ﮐﺮﺩ ﮐﻪ ﺁﻥ ﺭﺍ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺩﺭﺟﯽ ﺩﻭﺩﻭﻳـﻲ ﻣﻴﻨﺎﻣﻨـﺪ‬
‫ﮐﻪ ﺩﺭ ﺁﻥ ﻋﻤﻞ ﺟﺴﺘﺠﻮ ﺑﺮﺍﯼ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﻣﺤﻞ ﻋﻨﺼﺮ ‪ j‬ﺍﻡ ﺗﻮﺳﻂ ﺟﺴﺘﺠﻮﯼ ﺩﻭﺩﻭﻳﻲ ﺍﻧﺠﺎﻡ ﻣﻴﺸﻮﺩ ﻭﻟﯽ ﺯﻣﺎﻥ ﺍﺟﺮﺍﯼ ﺁﻥ‬
‫ﺗﻔﺎﻭﺗﯽ ﻧﺨﻮﺍﻫﺪ ﮐﺮﺩ‪.‬‬

‫)‪(Merge Sort‬‬
‫‪٢‬‬ ‫‪١‬‬ ‫‪١‬‬

‫ﺎ‬ ‫ﻏ‬ ‫ﻱ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬

‫ﻣ‬ ‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬ ‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﻲ‬ ‫ﺩ‬ ‫ﺍ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺍﮔﺮ ﻣﺠﻤﻮﻋﻪ ﺍﻱ ﺍﺯ ﺍﻋﺪﺍﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻭ ﺍﻳﻦ ﻣﺠﻤﻮﻋﻪ ﺭﺍ ﺑﻪ ﺩﻭ ﺑﺨﺶ ﺗﻘﺴﻴﻢ ﮐﻨﻴﻢ ﻭ ﻫﺮ ﺑﺨﺶ ﺭﺍ ﺟﺪﺍﮔﺎﻧﻪ ﻣﺮﺗﺐ ﮐﻨـﻴﻢ‬
‫ﻭ ﺣﺎﺻﻞ ﺭﺍ ﺑﻪ ﮔﻮﻧﻪ ﺍﻱ ﺍﺩﻏﺎﻡ ﮐﻨﻴﻢ ﮐﻪ ﺭﻋﺎﻳﺖ ﺗﺮﺗﻴﺐ ﺷﻮﺩ ﺁﻧﮕﺎﻩ ﮐﻞ ﻣﺠﻤﻮﻋﻪ ﺍﻋﺪﺍﺩ ﻣﺮﺗﺐ ﺧﻮﺍﻫﻨﺪ ﺷﺪ‪.‬‬
‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﻌﺪ ﺍﺯ ﺗﻘﺴﻴﻢ ﮐﺮﺩﻥ ﺩﺍﺩﻩ ﻫﺎﻱ ﺍﻭﻟﻴﻪ ﺑﻪ ﺩﻭ ﺑﺨﺶ‪ ،‬ﻫﺮ ﺑﺨﺶ ﺭﺍ ﻧﻴﺰ ﺑـﻪ ﻫﻤـﻴﻦ ﺗﺮﺗﻴـﺐ‪ ،‬ﻳﻌﻨـﻲ ﺗﻘﺴـﻴﻢ ﺑـﻪ‬
‫ﻣﺠﻤﻮﻋﻪ ﻫﺎﻱ ﮐﻮﭼﮑﺘﺮ ﻭ ﻣﺮﺗﺐ ﮐﺮﺩﻥ ﻭ ﺍﺩﻏﺎﻡ ﮐﺮﺩﻥ ﺁﻧﻬﺎ ﺑﺎ ﻫﻢ ﻣﺮﺗﺐ ﻣﻲ ﮐﻨﻴﻢ‪ .‬ﺍﻣﺎ ﺷﮑﺴﺘﻦ ﺯﻳﺮ ﻟﻴﺴـﺖﻫـﺎ ﺭﺍ ﺗـﺎ ﭼـﻪ‬
‫ﺯﻣﺎﻧﯽ ﺍﻧﺠﺎﻡ ﻣﻲ ﺩﻫﻴﻢ؟ ﺗﺎ ﺯﻣﺎﻧﻲ ﮐﻪ ﺗﻌﺪﺍﺩ ﻋﻨﺎﺻﺮ ﻫﺮ ﻟﻴﺴﺖ ﺑﺮﺍﺑﺮ ﺑﺎ ﻳﮏ ﺷﻮﺩ‪ .‬ﺁﻧﮕﺎﻩ ﺩﻭ ﻟﻴﺴﺖ ﮐﻮﭼﮏ ﺗﮏ ﻋﻨﺼﺮﻱ ﺭﺍ‬
‫ﺍﺩﻏﺎﻡ ﮐﺮﺩﻩ ﻭ ﺑﻪ ﺻﻮﺭﺕ ﺑﺎﺯﮔﺸﺘﻲ ﻋﻤﻞ ﻣﻲ ﮐﻨﻴﻢ‪ ،‬ﻣﺮﺍﺣﻞ ﮐﺎﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ ﺻﻮﺭﺕ ﺧﻼﺻﻪ ﺩﺭ ﺫﻳﻞ ﺁﻣﺪﻩ ﺍﺳﺖ‪:‬‬
‫ﺍﮔﺮ ﺗﻌﺪﺍﺩ ﺩﺍﺩﻩ ﻫﺎ ﻳﮑﻲ ﻳﺎ ﮐﻤﺘﺮ ﺍﺳﺖ ﻧﻴﺎﺯﻱ ﺑﻪ ﻣﺮﺗﺐ ﮐﺮﺩﻥ ﻧﻴﺴﺖ‪ ،‬ﺑﺮﮔﺮﺩ‪.‬‬
‫ﺩﺭ ﻏﻴﺮﺍﻳﻨﺼﻮﺭﺕ ﻭﺳﻂ ﺩﺍﺩﻩ ﻫﺎ ﺭﺍ ﭘﻴﺪﺍ ﮐﻦ‬
‫ﻧﻴﻤﻪ ﺍﻭﻝ ﺩﺍﺩﻩ ﻫﺎ ﺭﺍ ﺑﻪ ﺭﻭﺵ ‪) merge Sort‬ﻫﻤﻴﻦ ﺭﻭﺵ( ﻣﺮﺗﺐ ﮐﻦ‬
‫ﻧﻴﻤﻪ ﺩﻭﻡ ﺩﺍﺩﻩ ﻫﺎ ﺭﺍ ﺑﻪ ﺭﻭﺵ ‪) merge Sort‬ﻫﻤﻴﻦ ﺭﻭﺵ( ﻣﺮﺗﺐ ﮐﻦ‬
‫ﺩﻭﻧﻴﻤﻪ ﻣﺮﺗﺐ ﺷﺪﻩ ﺭﺍ ﺑﻪ ﮔﻮﻧﻪ ﺍﻱ ﺍﺩﻏﺎﻡ ﮐﻦ ﮐﻪ ﺣﺎﺻﻞ ﻣﺮﺗﺐ ﺑﺎﺷﺪ‪.‬‬
‫)‪Procedure mergesort(A,l,u‬‬
‫‪If l<u then‬‬
‫‪mid ← (l+u) / 2‬‬
‫)‪Mergesort(A,l, mid‬‬
‫)‪Mergesort(A,mid+1, u‬‬
‫)‪Merge(A, l, mid, u‬‬
‫‪endif‬‬
‫‪end.‬‬
‫‪٤‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫‪n‬‬
‫‪T (n) = 2T ( ) + n‬‬
‫‪2‬‬
‫‪n n‬‬ ‫‪n‬‬
‫‪= 2[T ( ) + ] + n = 4T ( ) + 2n‬‬
‫‪4 2‬‬ ‫‪4‬‬
‫‪n‬‬
‫‪= 8T ( ) + 3n‬‬
‫‪8‬‬
‫‪n‬‬
‫‪= 2i T ( i ) + in‬‬
‫‪2‬‬
‫)‪= 2 T (1) + n. log n = c.n + n.log n = Ο(n. log n‬‬
‫‪log n‬‬

‫ﺍﺯ ﺍﻳﻦ ﺭﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺍﺩﻏﺎﻣﯽ ﺩﺭ ﻫﻤﻪ ﺣﺎﻻﺕ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n. log n‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﻫﻤﭽﻨـﻴﻦ ﺑـﺪﻟﻴﻞ‬
‫ﺑﺎﺯﮔﺸﺘﯽ ﺑﻮﺩﻥ ﺑﻪ ﺍﻧﺪﺍﺯﻩ )‪ O(log n‬ﺍﺯ ﺣﺎﻓﻈﻪ ﭘﺸﺘﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻴﮑﻨﺪ‪ .‬ﻭﻟﯽ ﺑـﺎ ﻋﻴـﺮ ﺑﺎﺯﮔﺸـﺘﯽ ﻧﻮﺷـﺘﻦ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﻣﻴﺘـﻮﺍﻥ‬
‫ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓﯽ ﺭﺍ ﺑﻪ )‪ O(1‬ﮐﺎﻫﺶ ﺩﺍﺩ ﻭﻟﯽ ﺯﻣﺎﻥ ﻭﺍﻗﻌﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻴﺸﺘﺮ ﺧﻮﺍﻫﺪ ﺷﺪ!‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺍﺩﻏﺎﻣﯽ ﺑﺎﺯﮔﺸﺘﯽ ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺻﻮﺭﺗﻬﺎﯼ ﻣﺘﻔﺎﻭﺗﯽ ﺍﺯ ﺟﻤﻠﻪ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺍﺩﻏﺎﻣﯽ ﻃﺒﻴﻌﯽ ‪(Natural‬‬
‫)‪ Merge Sort‬ﻭ ﻳﺎ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺍﺩﻏﺎﻣﯽ ﻏﻴﺮ ﺑﺎﺯﮔﺸﺘﯽ ﺑﺎﺯﻧﻮﻳﺴﯽ ﮐﺮﺩ‪.‬‬

‫)‪(Quick Sort‬‬
‫‪٣‬‬ ‫‪١‬‬ ‫‪١‬‬

‫ﺳ‬ ‫ﻱ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬

‫ﻊ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺑﺮﺍﺳﺎﺱ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﻴﺰ ﻣﺠﻤﻮﻋﻪ ﺍﻋﺪﺍﺩ ﻳﺎ ﺑﻪ ﻃﻮﺭﮐﻠﻲ ﺩﺍﺩﻩ ﻫﺎ ﺑﻪ ﺩﻭ ﺑﺨﺶ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ ﻭ ﻫـﺮ ﺑﺨـﺶ ﺟﺪﺍﮔﺎﻧـﻪ‬
‫ﻣﺮﺗﺐ ﻣﻲ ﺷﻮﻧﺪ‪ .‬ﺗﻔﺎﻭﺕ ﻫﺎﻱ ﻋﻤﺪﻩ ﺑﻴﻦ ﺭﻭﺵ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﻭ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺍﺩﻏﺎﻡ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻫﺴﺘﻨﺪ‪:‬‬
‫ﺍﻭﻝ ﺍﻳﻨﮑﻪ ﺩﺭ ﺭﻭﺵ ﻣﺮﺗﺐ ﺳﺎﺯﻱ ﺳﺮﻳﻊ ﻳﮑﻲ ﺍﺯ ﻋﻨﺎﺻﺮ ﻣﺠﻤﻮﻋﻪ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﻋﻨﺼﺮ ﻣﺤﻮﺭﻱ ﺍﻧﺘﺨﺎﺏ ﻣﻲﮐﻨﻴﻢ ﮐﻪ ﻓﺮﻗـﻲ‬
‫ﻧﻤﻲ ﮐﻨﺪ ﮐﺪﺍﻡ ﻋﻨﺼﺮ ﺍﺯ ﻣﺠﻤﻮﻋﻪ ﺑﺎﺷﺪ‪.‬‬
‫ﺩﻭﻡ ﺍﻳﻨﮑﻪ ﻣﺠﻤﻮﻋﻪ ﺩﺭﻭﺍﻗﻊ ﺑﻪ ﺳﻪ ﻗﺴﻤﺖ ﺷﮑﺴﺘﻪ ﻣـﻲ ﺷـﻮﺩ ﺍﻟـﻒ( ﻋﻨﺼـﺮ ﻣﺤـﻮﺭﻱ ﺏ( ﻋﻨﺼـﺮ ﮐـﻮﭼﮑﺘﺮ ﺍﺯ ﻋﻨﺼـﺮ‬
‫ﻣﺤﻮﺭﻱ ﺝ( ﻋﻨﺎﺻﺮ ﺑﺰﺭﮔﺘﺮ ﺍﺯ ﻋﻨﺼﺮ ﻣﺤﻮﺭﻱ‬
‫ﺳﻮﻡ ﺍﻳﻨﮑﻪ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻣﺤﻞ ﻋﻨﺼﺮ ﻣﺤﻮﺭﻱ ﺩﺭ ﺁﺭﺍﻳﻪ ﺛﺎﺑﺖ ﻣﻲ ﺷﻮﺩ ﻭ ﺩﺭ ﻭﺍﻗﻊ ﻣﮑﺎﻧﺶ ﭘﻴﺪﺍ ﻣﻲ ﺷﻮﺩ ﻭ ﭼﻬﺎﺭﻡ ﺍﻳﻨﮑـﻪ‬
‫ﺍﺣﺘﻴﺎﺟﻲ ﺑﻪ ﺍﺩﻏﺎﻡ ﻫﺮ ﻣﺠﻤﻮﻋﻪ ﻧﻴﺴﺖ‪ .‬ﺑﻠﮑﻪ ﺩﺭ ﺣﻘﻴﻘﺖ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﺍﺟﺮﺍﺀ ﻣﺤﻞ ﻳﮏ ﻋﻀﻮ ﺍﺯ ﺁﺭﺍﻳﻪ ﺛﺎﺑﺖ ﻣـﻲ ﺷـﻮﺩ‪.‬‬
‫)ﻫﻤﺎﻥ ﻋﻀﻮ ﻣﺤﻮﺭﻱ(‬
‫ﺑﻌﺪ ﺍﺯ ﻳﺎﻓﺘﻦ ﻣﺤﻞ ﺛﺎﺑﺖ ﻋﻀﻮ ﻣﺤﻮﺭﻱ )‪ (Partition Phase‬ﻫﺮ ﻳﮏ ﺍﺯ ﺩﻭ ﺑﺨﺶ ﺩﻳﮕﺮ ﻧﻴﺰ ﺑﻪ ﺭﻭﺵ ﻓﻮﻕ ﺑﻪ ﺻﻮﺭﺕ‬
‫ﺑﺎﺯﮔﺸﺘﯽ ﻣﺮﺗﺐ ﻣﻲ ﺷﻮﻧﺪ)‪.(Recursion Phase‬‬
‫ﺑﻪ ﺭﺍﺣﺘﯽ ﻗﺎﺑﻞ ﻣﻼﺣﻈﻪ ﺍﺳﺖ ﮐﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭﺿﻌﻴﺖ )ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﺍﺯ ﻗﺒﻞ ﻣﺮﺗﺐ ﺑﺎﺷﻨﺪ( ﺩﺭ ﻫـﺮ ﻣﺮﺣﻠـﻪ‬
‫ﻟﻴﺴﺖ ﺭﺍ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺑﺎ ﺍﻧﺪﺍﺯﻩ ﻫﺎﯼ ﮐﺎﻣﻼﹰ ﺩﻭﺭ ﺍﺯ ﻫﻢ ﺗﻘﺴﻴﻢ ﻣﻴﮑﻨﺪ ﻭ ﻟﺬﺍ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n2‬ﺧﻮﺍﻫﺪ ﺑـﻮﺩ!‪ .‬ﻭ‬
‫ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﻭﺿﻌﻴﺖ )ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﺑﺎﺷﻨﺪ ﮐﻪ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻋﻨﺼﺮ ﻣﻴﺎﻧﻪ ﺑﻪ ﻋﻨﻮﺍﻥ ﻗﻠﻢ ﻣﺤﻮﺭﯼ ﺍﻧﺘﺨﺎﺏ ﺷﻮﺩ(‬
‫ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻟﻴﺴﺖ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺑﺎ ﺍﻧﺪﺍﺯﻩ ﻧﺰﺩﻳﮏ ﺑﻪ ﻫﻢ ﺗﻘﺴﻴﻢ ﻣﻴﺸـﻮﺩ ﻭ ﻟـﺬﺍ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒـﻪ ﺯﻣـﺎﻧﯽ )‪O(n. log n‬‬
‫ﺧﻮﺍﻫﺪ ﺑﻮﺩ!‪ .‬ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻄﻮﺭ ﻣﺘﻮﺳﻂ ﻧﻴﺰ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n. log n‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ!‪ .‬ﻫﻤﭽﻨﻴﻦ ﺍﺯ ﻟﺤﺎﻅ ﻣﺼﺮﻑ‬
‫ﺣﺎﻓﻈﻪ ﮐﻤﮑﯽ ﻧﻴﺰ ﺑﻪ ﺩﻟﻴﻞ ﺑﺎﺯﮔﺸﺘﯽ ﺑﻮﺩﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﺑﺮﺍﺑـﺮ ﺑـﺎ )‪ O(n‬ﻭ ﺩﺭ ﺑﻬﺘـﺮﻳﻦ ﺣﺎﻟـﺖ ﻭ ﺣﺎﻟـﺖ‬
‫ﻣﺘﻮﺳﻂ ﺑﺮﺍﺑﺮ ﺑﺎ )‪ O(log n‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫‪٥‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫)‪Procedure Quick_Sort( A, l, u‬‬

‫‪If l < u then‬‬
‫]‪Pivot ← A[l‬‬
‫‪i←l‬‬
‫;‪j←u‬‬
‫‪repeat‬‬
‫‪Do i ← i + 1 until A[i] > pivot‬‬
‫‪Do j ← j - 1 until A[j] < pivot‬‬
‫‪If i < j then‬‬
‫)]‪Swap(A[i], A[j‬‬
‫‪Endif‬‬
‫‪Until i ≥ j‬‬
‫)]‪Swap(A[l], A[j‬‬
‫)‪Quick_Sort(A, l, j - 1‬‬
‫)‪Quick_Sort(A, j + 1, u‬‬
‫‪endif‬‬
‫‪End.‬‬

‫)‪(Heap Sort‬‬
‫‪٤‬‬ ‫‪١‬‬ ‫‪١‬‬

‫ﯼ‬ ‫ﻱ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬

‫ﻩ‬
‫ﺗ‬ ‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺍ‬ ‫ﺩ‬ ‫ﻮ‬

‫ﻗﺒﻞ ﺍﺯ ﺗﻮﺿﻴﺢ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻳﺪ ﺩﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﻮﺭﺩ ﻧﻴﺎﺯ ﺭﺍ ﻳﺎﺩﺁﻭﺭﯼ ﮐﻨﻴﻢ‪:‬‬

‫‪ :Adjust‬ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﺩﺭﺧﺘﯽ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﺍﺯ ‪ Heap‬ﺑﻮﺩﻥ ﺯﻳﺮ ﺩﺭﺧﺖ ﭼـﭗ‬ ‫•‬
‫ﻭ ﺭﺍﺳﺖ ﺁﻥ ﻣﻄﻤﺌﻦ ﻫﺴﺘﻴﻢ ﻭﻟﯽ ﺗﻈﻤﻴﻨﯽ ﺑﺮ ‪ Heap‬ﺑﻮﺩﻥ ﮐﻞ ﺩﺭﺧﺖ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﻭ ﻟﺬﺍ ﺷﺒﻴﻪ ﻋﻤـﻞ ﺣـﺬﻑ‬
‫ﻋﻨﺼﺮ ﺑﻴﺸﻴﻨﻪ ﺍﺯ ﻳﮏ ‪ MaxHeap‬ﻋﻤﻞ ﻣﻴﮑﻨﻴﻢ ﻭ ﺭﻳﺸﻪ ﺭﺍ ﺑﺎ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻓﺮﺯﻧﺪﺍﻧﺶ )ﺩﺭ ﺻـﻮﺭﺕ ﻭﺟـﻮﺩ( ﺗـﺎ‬
‫ﺟﺎﯼ ﻣﻮﺭﺩ ﻧﻴﺎﺯ ﺑﻪ ﺳﻤﺖ ﺑﺮﮔﻬﺎ ﭘﻴﺶ ﻣﻴﺒﺮﻳﻢ‪ .‬ﻭ ﻟﺬﺍ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(log n‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫‪ :Heapify‬ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻳﮏ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﮐﺎﻣﻞ ﺑﻪ ﻳﮏ ‪ Heap‬ﺗﺒﺪﻳﻞ ﻣﻴﺸﻮﺩ‪ .‬ﺑـﺎ ﺷـﺮﻭﻉ ﺍﺯ ﻋﻨﺼـﺮ‬ ‫•‬
‫‪) n/2‬ﺁﺧﺮﻳﻦ ﻋﻨﺼﺮ ﺩﺍﺭﺍﯼ ﻓﺮﺯﻧﺪ( ﺑﻪ ﺳﻤﺖ ﻋﻨﺼﺮ ﺳﺮ ﻟﻴﺴﺖ ﭘﻴﺶ ﻣﻴﺮﻭﻳﻢ ﻭ ﺁﻥ ﺭﺍ ﺩﺭ ﻋﻨﺎﺻﺮ ﺑﻌـﺪ ﺍﺯ ﺧـﻮﺩ‬
‫‪ adjust‬ﻣﻴﮑﻨﻴﻢ‪ .‬ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺮﺍﺑﺮ ﺑﺎ )‪ O(n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫)‪Procedure Adjust(A, i, n‬‬

‫‪j← 2*i‬‬
‫)‪item←A(i‬‬
‫‪while j≤n do‬‬
‫‪if j<n and A(j)<A(j+1) then j←j+1 endif‬‬
‫‪if item ≥A(j) then‬‬
‫‪exit‬‬
‫‪else‬‬
‫)‪A(j/2)←A(j‬‬
‫‪j←2*j‬‬
‫‪endif‬‬
‫‪repeat‬‬
‫‪A(j/2)←item‬‬
‫‪end.‬‬
‫‪٦‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫)‪Procedure Heapify(A, n‬‬

‫‪for i← i/2 to 1 do‬‬
‫)‪call adjust(A,i,n‬‬
‫‪repeat‬‬
‫‪end.‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Heapify‬ﺑﻪ ﺩﻟﻴﻞ ﺯﻳﺮ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n‬ﺍﺳﺖ!‪.‬‬

‫‪j = k −i‬‬
‫‪k‬‬ ‫}‬ ‫‪k −1‬‬
‫‪j‬‬ ‫‪k −1‬‬‫‪k −1‬‬
‫‪j‬‬ ‫∞‬
‫‪j‬‬
‫‪∑ (k − i)2‬‬
‫‪i =1‬‬
‫‪i −1‬‬
‫∑‬‫‪j =0‬‬
‫=‬ ‫∑ ‪j.2 k − j −1 = 2 k −1‬‬
‫‪j =0 2‬‬
‫‪j‬‬
‫≤‬ ‫‪n‬‬ ‫∑‬
‫‪j =0 2‬‬
‫‪j‬‬
‫≤‬ ‫‪n‬‬ ‫∑‬
‫‪j =0 2‬‬
‫‪j‬‬
‫) ‪= 2n = Ο( n‬‬

‫ﮐﻪ ﺩﺭ ﺁﻥ ‪ i‬ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﺳﻄﺢ ﮔﺮﻩ ﻫﺎﯼ ﺩﺭﺧﺖ‪ k ،‬ﺑﺮﺍﺑﺮ ﺑﺎ ﻋﻤﻖ ﺩﺭﺧﺖ ) ‪ ( log (n + 1)‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﻭﺍﺿﺢ ﺍﺳـﺖ ﮐـﻪ‬
‫ﺗﻌﺪﺍﺩ ﮔﺮﻩ ﻫﺎﯼ ﺳﻄﺢ ‪ i‬ﺍﻡ ﺩﺭﺧﺖ ﺣﺪﺍﮐﺜﺮ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ 2i-1‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﺩﺭ ﻣﺮﺗﺐﺳﺎﺯﻱ ﺗﻮﺩﻩﺍﯼ ﺍﺑﺘﺪﺍ ﻟﻴﺴﺖ ﻳﺎ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﻪ ﻳﮏ‬
‫‪ Heap‬ﺗﺒﺪﻳﻞ ﻣﻴﮑﻨﻴﻢ )ﺑﻪ ﮐﻤﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ (Heapify‬ﻭ ﺳﭙﺲ ﺑﻌﺪ ﺍﺯ ‪ Heap‬ﺷﺪﻥ ﻟﻴﺴﺖ ﻋﻨﺎﺻﺮ ﺳﺮ ﺩﺭﺧﺖ )ﻋﻨﺼـﺮ‬
‫ﻣﺎﮐﺰﻳﻤﻢ( ﺭﺍ ﺑﺎ ﻋﻨﺼﺮ ﺍﻧﺘﻬﺎﯼ ﻟﻴﺴﺖ ﺟﺎﺑﻪﺟﺎ ﮐﺮﺩﻩ ﻭ ﺩﻭﺑﺎﺭﻩ ﺑﺪﻭﻥ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻋﻨﺼﺮ ﺟﺎﺑﻪﺟﺎ ﺷﺪﻩ )ﺩﺭ ﺍﻧﺘﻬﺎ( ﺩﺭﺧـﺖ‬
‫ﺭﺍ ﺑﺎ ﮐﻤﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ adjust‬ﺑﻪ ﻳﮏ ‪ Heap‬ﺗﺒﺪﻳﻞ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺍﻳﻦ ﻋﻤﻞ ‪ n-1‬ﺑﺎﺭ ﺻﻮﺭﺕ ﻣﻴﮕﻴﺮﺩ ﻭ ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﻋﻨﺎﺻﺮ‬
‫ﺍﺯ ﺑﻴﺸﻴﻨﻪ ﺑﻪ ﮐﻤﻴﻨﻪ ﺍﺯ ﺍﻧﺘﻬﺎﯼ ﺁﺭﺍﻳﻪ ﺑﻪ ﺳﻤﺖ ﺍﺑﺘﺪﺍﯼ ﺁﺭﺍﻳﻪ ﭼﻴﺪﻩ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬
‫ﺑﺮﺍﻱ ﻣﺮﺗﺐﺳﺎﺯﻱ ﻟﻴﺴﺖ‪ ،‬ﺍﺑﺘﺪﺍ ﻳﻚ ‪ heap‬ﺑﺰﺭﮒ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻓﺮﺧﻮﺍﻧﻲ ﻣﺘﻮﺍﻟﻲ ‪ adjust‬ﺍﻳﺠﺎﺩ ﻣﻲﻛﻨـﻴﻢ ﻭ ﺳـﭙﺲ ‪n-1‬‬
‫ﮔﺬﺭ ﺭﻭﻱ ﻟﻴﺴﺖ ﺩﺍﺭﻳﻢ‪ .‬ﺩﺭ ﻫﺮﮔﺬﺭ ﺍﻭﻟﻴﻦ ﺭﻛﻮﺭﺩ ‪ heap‬ﺭﺍ ﺑﺎ ﺁﺧﺮﻳﻦ ﺭﻛﻮﺭﺩ ﺗﻌﻮﻳﺾ ﻣـﻲﻛﻨـﻴﻢ‪ .‬ﭼـﻮﻥ ﺍﻭﻟـﻴﻦ ﺭﻛـﻮﺭﺩ‬
‫ﺷﺎﻣﻞ ﺑﺰﺭﮔﺘﺮﻳﻦ ﻛﻠﻴﺪ ﺍﺳﺖ‪ ،‬ﺍﻳﻦ ﺭﻛﻮﺭﺩ ﺍﻛﻨﻮﻥ ﺩﺭ ﻣﻮﻗﻌﻴﺖ ﻣﺮﺗﺐ ﺷﺪﻥ ﺧـﻮﺩﺵ ﺍﺳـﺖ ﭘـﺲﺍﻧـﺪﺍﺯﻩ ‪ heap‬ﺭﺍ ﻛـﺎﻫﺶ‬
‫ﻣﻲﺩﻫﻴﻢ ﻭ ﺩﻭﺑﺎﺭﻩ ﺁﻥ ﺭﺍ ﺗﺮﺍﺯ ﻣﻲﻛﻨﻴﻢ‪ ،‬ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ‪ ،‬ﺩﺭ ﺍﻭﻟﻴﻦ ﮔﺬﺭ‪ ،‬ﺭﻛﻮﺭﺩﻱ ﺑﺎ ﺑﺰﺭﮔﺘﺮﻳﻦ ﻛﻠﻴـﺪ ﺭﺍ ﺩﺭ ‪ n‬ﺍﹸﻣـﻴﻦ ﻣﺤـﻞ‬
‫ﻣﻲﮔﺬﺍﺭﻳﻢ‪ ،‬ﺩﺭ ﮔﺬﺭ ﺩﻭﻡ ﺭﻛﻮﺭﺩﻱ ﺑﺎ ﺩﻭﻣﻴﻦ ﻛﻠﻴﺪ ﺑﺰﺭﮔﻲ ﺭﺍ ﺩﺭ ﻣﺤﻞ ‪ n-1‬ﻣﻲﮔﺬﺍﺭﻳﻢ ﻭ ‪ i‬ﺍﹸﻣﻴﻦ ﮔﺬﺭ ﺭﻛﻮﺭﺩﻱ ﺑﺎ ‪ i‬ﺍﹸﻣـﻴﻦ‬
‫ﻛﻠﻴﺪ ﺑﺰﺭﮔﻲ ﺭﺍ ﺩﺭ ﻣﺤﻞ ‪ n-i+1‬ﻣﻲﮔﺬﺍﺭﻳﻢ‪.‬‬
‫ﺍﺯ ﺍﻳﻦ ﺭﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺗﻮﺩﻩﺍﯼ ﺩﺭ ﻫﻤﻪ ﺣﺎﻻﺕ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n. log n‬ﻣﻴﺒﺎﺷﺪ!‪ .‬ﻫﻤﭽﻨـﻴﻦ ﺑـﺪﻟﻴﻞ‬
‫ﻏﻴﺮ ﺑﺎﺯﮔﺸﺘﯽ ﺑﻮﺩﻥ ﺩﺍﺭﺍﯼ ﺣﺎﻓﻈﻪ ﻣﺼﺮﻓﯽ )‪ O(1‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬

‫)‪Procedure HeapSort(A, n‬‬

‫)‪call Heapify(A,n‬‬
‫‪for i←n to 2 do‬‬
‫))‪Swap(A(i), A(1‬‬
‫)‪call Adjust(A,1,i-1‬‬
‫‪repeat‬‬
‫‪end.‬‬

‫‪٢‬‬ ‫‪١‬‬

‫ﻣ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﺷ‬ ‫ﻮ‬ ‫ﺭ‬ ‫ﺩ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻢ‬ ‫ﻤ‬

‫ﻴ‬ ‫ﻨ‬ ‫ﻴ‬ ‫ﭘ‬ ‫ﺖ‬ ‫ﺧ‬

‫)‪(Kruskal‬‬
‫ﻝ‬

‫‪١‬‬ ‫‪٢‬‬ ‫‪١‬‬

‫ﺎ‬ ‫ﺷ‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺍ‬ ‫ﺭ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺩﺭﺧﺖ ﭘﻮﺷﺎﻱ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ‪ ،T‬ﻟﺒﻪ ﺑﻪ ﻟﺒﻪ ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮﺩ‪ .‬ﻟﺒﻪ ﻫﺎﻱ ﻣـﻮﺭﺩ ﺍﺳـﺘﻔﺎﺩﻩ ﺩﺭ‪ ،T‬ﺑـﻪ ﺗﺮﺗﻴـﺐ‬
‫ﺻﻌﻮﺩﻱ ﻭﺯﻧﻬﺎ ﻣﻲ ﺑﺎﺷﺪ‪ .‬ﻳﮏ ﻟﺒﻪ ﺩﺭ ‪ T‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ ،‬ﺍﮔﺮ ﺑﺎ ﻟﺒﻪ ﻫﺎﻱ ﻗﺒﻞ ﮐﻪ ﺩﺭ‪ T‬ﺑﻮﺩﻩ ﺍﻧﺪ ﺗﺸﮑﻴﻞ ﺣﻠﻘﻪ ﻧﺪﻫﺪ‪.‬‬
‫‪٧‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫)‪(Prim‬‬
‫‪٢‬‬ ‫‪٢‬‬ ‫‪١‬‬

‫ﻢ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﭘ‬ ‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺩﺭﺧﺖ ﭘﻮﺷﺎﻱ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ‪ ، T‬ﺭﺍﺱ ﺑﻪ ﺭﺍﺱ ﺑﻪ ‪ T‬ﮐﻪ ﺩﺭ ﺍﺑﺘﺪﺍ ﺷﺎﻣﻞ ﻳﮑﯽ ﺍﺯ ﺭﺋـﻮﺱ )ﺑـﻪ ﺩﻟﺨـﻮﺍﻩ(‬
‫ﺍﺳﺖ‪ ،‬ﺍﺿﺎﻓﻪ ﻣﻴﺸﻮﻧﺪ‪ .‬ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻳﺎﻝ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﮐﻪ ﻳﮏ ﺭﺍﺱ ﻣﺠﺎﻭﺭ ﺁﻥ ﺩﺍﺧـﻞ ‪ T‬ﻭ ﺭﺍﺱ ﻣﺠـﺎﻭﺭ ﺩﻳﮕـﺮﺵ‬
‫ﺧﺎﺭﺝ ﺍﺯ ‪ T‬ﺑﺎﺷﺪ ﺑﻪ ﺩﺭﺧﺖ ﺍﺿﺎﻓﻪ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﺩﻭ ﺍﻟﮕﺮﻳﺘﻢ ﺑﺎﻻ ﺑﻪ ﻃﻮﺭ ﮐﺎﻣﻞ ﺩﺭ ﻓﺼﻞ ﻣﺮﺑﻮﻁ ﺑﻪ ﺭﻭﺵ ﻃﺮﺍﺣﯽ ﺣﺮﻳﺼﺎﻧﻪ ﺷﺮﺡ ﺩﺍﺩﻩ ﺧﻮﺍﻫﻨﺪ ﺷﺪ‪.‬‬

‫ﻑ‬ ‫ﺍ‬

‫‪٣‬‬ ‫‪١‬‬

‫ﺎ‬ ‫ﻫ‬ ‫ﺮ‬ ‫ﯼ‬ ‫ﻮ‬ ‫ﺠ‬ ‫ﺘ‬ ‫ﺴ‬ ‫ﺟ‬ ‫ﻭ‬ ‫ﺶ‬ ‫ﻳ‬ ‫ﺎ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬

‫ﮔ‬ ‫ﻴ‬ ‫ﭘ‬

‫‪DFS‬‬
‫(‬ ‫)‬

‫ﻘ‬

‫‪١‬‬ ‫‪٣‬‬ ‫‪١‬‬

‫ﺶ‬

‫ﻤ‬ ‫ﻋ‬ ‫ﺎ‬ ‫ﻤ‬ ‫ﻴ‬

‫ﻳ‬ ‫ﭘ‬ ‫ﻭ‬ ‫ﺘ‬ ‫ﺴ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﯽ‬ ‫ﻮ‬ ‫ﺠ‬ ‫ﺟ‬

‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﭘﻴﻤﺎﻳﺶ ﮔﺮﻩ ﻫﺎ ﺩﺭ ﺍﻣﺘﺪﺍﺩ ﻳﮏ ﺷﺎﺧﻪ ﺗﺎ ﺍﻧﺘﻬﺎﻱ ﺁﻥ ﺍﺩﺍﻣﻪ ﭘﻴﺪﺍ ﻣﻲ ﮐﻨﺪ ﻭ ﺑﺎ ﭘﺎﻳﺎﻥ ﻳﺎﻓﺘﻦ ﺷﺎﺧﻪﻫﺎ ﻳﮏ ﻣﺮﺣﻠﻪ‬
‫ﺑﻪ ﻋﻘﺐ ﺑﺮﮔﺸﺖ ﮐﺮﺩﻩ ﻭ ﻣﺠﺪﺩﺍﹰ ﺑﺮﺭﺳﯽ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎ ﻣﺸﺎﻫﺪﻩ ﻳﮏ ﮔﺮﻩ ﺟﺪﻳﺪ‪ ،‬ﭘﻴﻤﺎﻳﺶ ﺳﺎﻳﺮ ﻓﺮﺯﻧﺪﺍﻥ ﮔـﺮﻩ‬
‫ﻗﺒﻠﻲ ﺑﻪ ﺗﻌﻮﻳﻖ ﺍﻓﺘﺎﺩﻩ ﻭ ﮔﺮﻩ ﺟﺪﻳﺪ ﺑﺮﺭﺳﻲ ﻣﻲ ﺷﻮﺩ‪ .‬ﺩﺭ ﻭﺍﻗﻊ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎ ﮔﺬﺭ ﺍﺯ ﻫﺮ ﮔﺮﻩ ﺑﻪ ﺳﻤﺖ ﻋﻤـﻖ ﺩﺭﺧـﺖ‬
‫ﮔﺮﻩ ﻓﻌﻠﯽ ﺩﺭ ﭘﺸﺘﻪ ﻗﺮﺍﺭ ﺩﺍﺩﻩ ﻣﻴﺸﻮﺩ ﮐﻪ ﺑﺎ ﺑﺎﺯﮔﺸﺘﯽ ﻃﺮﺍﺣﯽ ﮐﺮﺩﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﭘﺸﺘﻪ ﻣﻮﺭﺩ ﻧﻈﺮ ﺑﻪ ﺻـﻮﺭﺕ ﭘﻨﻬـﺎﻥ ﺳـﺎﺧﺘﻪ‬
‫ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬

‫)‪Procedure DFS(v‬‬
‫)‪Visit(v‬‬
‫‪For each vertex w adjacent to v do‬‬
‫‪If not visited w then‬‬
‫)‪DFS( w‬‬
‫‪Endif‬‬
‫‪repeat‬‬
‫‪end‬‬

‫ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭﺿﻌﻴﺖ )ﮔﺮﺍﻑ ﻫﻤﺒﻨﺪ ﺑﺎﺷﺪ( ﻫﺮ ﻳﺎﻝ ﺣﺪﺍﮐﺜﺮ ﺩﻭ ﺑﺎﺭ ﭘﻴﻤﻮﺩﻩ ﻣﻴﺸـﻮﺩ )!( ﻭ ﻫـﺮ ﺭﺍﺱ ﻧﻴـﺰ‬
‫ﻳﮑﺒﺎﺭ ﻣﻼﻗﺎﺕ ﻣﻴﺸﻮﺩ ﻭ ﻟﺬﺍ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ )‪ O(n+e‬ﺍﺳﺖ‪.‬‬

‫‪(BFS‬‬
‫)‬

‫‪٢‬‬ ‫‪٣‬‬ ‫‪١‬‬

‫ﺶ‬

‫ﺎ‬ ‫ﻤ‬ ‫ﻴ‬

‫ﻳ‬ ‫ﻳ‬ ‫ﭘ‬ ‫ﻭ‬ ‫ﺘ‬ ‫ﺴ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﯽ‬ ‫ﻔ‬ ‫ﺩ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﺠ‬ ‫ﺟ‬

‫ﺍﮔﺮ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻗﺒﻠﯽ ﺑﻪ ﺟﺎﯼ ﭘﺸﺘﻪ ﻳﮏ ﺻﻒ ﺩﺭ ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ ﺑﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺟﺪﻳﺪﯼ ﺧﻮﺍﻫﻴﻢ ﺭﺳﻴﺪ ﮐﻪ ‪ BFS‬ﻧـﺎﻡ ﺩﺍﺭﺩ‪.‬‬
‫ﺑﺮﺍﻱ ﭘﻴﻤﺎﻳﺶ ﮐﻠﻴﻪ ﮔﺮﻩ ﻫﺎ ﮔﺮﻩ ﺁﻏﺎﺯ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻲ ﮐﻨﻴﻢ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﻌﺪ ﺍﺯ ﺩﻳﺪﻥ ﻫﺮﮔﺮﻩ ﮐﻠﻴﻪ ﻓﺮﺯﻧـﺪﺍﻥ ﻫﻤـﺎﻥ ﮔـﺮﻩ‬
‫ﻣﻼﻗﺎﺕ ﺷﺪﻩ ﻭ ﺳﭙﺲ ﻓﺮﺯﻧﺪﺍﻥ ﺍﻭﻟﻴﻦ ﻓﺮﺯﻧﺪ ﮔﺮﻩ ﺍﺻﻠﻲ ﻭ ﺑﻌﺪ ﻓﺮﺯﻧﺪﺍﻥ ﺩﻭﻣﻴﻦ ﻓﺮﺯﻧﺪ ﮔﺮﻩ ﺍﺻﻠﻲ ﻭ ﺗﺎ ﺍﻧﺘﻬﺎ ﭘﻴﺶ ﻣﻲ ﺭﻭﺩ‪.‬‬
‫‪٨‬‬ ‫ﻳﺎﺩﺁﻭﺭﻱ‬

‫ﺑﻨﺎﺑﺮﺍﻳﻦ ﺭﻭﺵ ﮐﺎﺭ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﻧﺨﺴﺖ ﺩﻭﻣﻴﻦ ﮔﺮﻩ ﺭﺍ ﻣﻼﻗﺎﺕ ﻣﻲ ﮐﻨﻴﻢ ﻭ ﺳﭙﺲ ﮐﻠﻴﻪ ﻓﺮﺯﻧﺪﺍﻥ ﺁﻥ ﺭﺍ ﻣﻼﻗـﺎﺕ ﮐـﺮﺩﻩ ﻭ‬
‫ﺩﺭ ﺍﻧﺘﻬﺎﯼ ﺻﻒ ﻗﺮﺍﺭ ﻣﻲ ﺩﻫﻴﻢ ﻭ ﺳﭙﺲ ﺍﺯ ﺩﺍﺧﻞ ﺻﻒ‪ ،‬ﺍﻭﻟﻴﻦ ﮔﺮﻩ ﺭﺍ ﺑﺮﺩﺍﺷـﺘﻪ ﻭ ﻓﺮﺯﻧـﺪﺍﻥ ﺁﻥ ﺭﺍ ﻣﻼﻗـﺎﺕ ﮐـﺮﺩﻩ ﻭ ﺑـﻪ‬
‫ﺍﻧﺘﻬﺎﻱ ﺻﻒ ﻣﻲ ﺍﻓﺰﺍﻳﻴﻢ‪.‬‬
‫)‪Procedure BFS(v‬‬
‫)‪Visit(v‬‬
‫)‪AddQueue(v‬‬
‫‪While Queue is not empty do‬‬
‫)‪DeleteQueue(v‬‬
‫‪For each w adjacent to v do‬‬
‫‪If not visited w then‬‬
‫)‪Visit(w‬‬
‫)‪AddQueue(w‬‬
‫‪Endif‬‬
‫‪Repeat‬‬
‫‪Repeat‬‬
‫‪end‬‬

‫ﻃﺒﻖ ﺩﻟﻴﻞ ﻣﻄﺮﺡ ﺷﺪﻩ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ DFS‬ﻟﺬﺍ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﻴﺰ )‪ O(n+e‬ﺍﺳﺖ‪.‬‬
‫ﺗﻮﺳﻂ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ‪ DFS‬ﻭ ‪ BFS‬ﻣﻴﺘﻮﺍﻥ ﻳﮏ ﮔﺮﺍﻑ ﻏﻴﺮ ﻫﻤﺒﻨﺪ ﺭﺍ ﻧﻴﺰ ﭘﻴﻤﺎﻳﺶ ﮐﺮﺩ‪ .‬ﺑﻪ ﺍﻳﻦ ﺻـﻮﺭﺕ ﮐـﻪ ﻫـﺮ ﺑـﺎﺭ ﺍﺯ‬
‫ﻳﮏ ﮔﺮﻩ ﻣﻼﻗﺎﺕ ﻧﺸﺪﻩ ﺷﺮﻭﻉ ﮐﺮﺩﻩ ﻭ ﺁﻥ ﺭﺍ ‪ DFS‬ﻳﺎ ‪ BFS‬ﻣﻴﮑﻨﻴﻢ ﻭ ﻟﺬﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﻳﻲ ﻣﺒﺘﻨـﯽ ﺑـﺮ ﭘﻴﻤـﺎﻳﺶ‬
‫ﻋﻤﻘﯽ ﻳﺎ ﺭﺩﻳﻔﯽ ﺭﺳﻴﺪ‪.‬‬
 ‫‪۲‬‬

‫ﺎ‬ ‫ﻬ‬ ‫ﻤ‬ ‫ﺘ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬ ‫ﻞ‬ ‫ﻴ‬ ‫ﻠ‬ ‫ﺤ‬ ‫ﺗ‬ ‫‪-‬‬

‫ﺩﺭ ﺍﻳﻦ ﺑﺨﺶ ﺑﻪ ﺗﻌﺮﻳﻒ ﻧﻤﺎﺩﻫﺎﯼ ﻣﺠﺎﻧﺒﯽ ﻣﻮﺭﺩ ﻧﻴﺎﺯ ﺩﺭ ﺗﺤﻠﻴـﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬـﺎ ﻭ ﺑﻴـﺎﻥ ﭼﻨـﺪ ﻗﻀـﻴﻪ ﻗﻀـﻴﻪ ﺩﺭ ﻣـﻮﺭﺩ ﺁﻥ‬
‫ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬

‫‪۱‬‬ ‫‪۲‬‬

‫ﻧ‬ ‫ﺎ‬ ‫ﺠ‬ ‫ﻣ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﻫ‬ ‫ﺩ‬ ‫ﺎ‬ ‫ﻧ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬

‫ﯽ‬ ‫ﺒ‬

‫ﺗﻌﺮﻳﻒ‪ f(n)∈O(g(n)) :‬ﺍﮔﺮ ﻭ ﻓﻘﻂ ﺍﮔﺮ ﺛﺎﺑﺖ‪ c‬ﻭ ﺛﺎﺑﺖ ‪ no‬ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ ﮐﻪ ﺑﺮﺍﻱ ﻫﻤﻪ ﻣﻘﺎﺩﻳﺮ ‪ ، n ≥ no‬ﺩﺍﺷﺘﻪ‬
‫ﺑﺎﺷﻴﻢ‪.‬‬
‫)‪∀ n ≥ n0 : f (n) ≤ c g (n‬‬
‫‪f ( n ) ∈ Ω  g ( n ) ‬‬
‫ﺍﮔﺮ ﻭ ﻓﻘﻂ ﺍﮔﺮ ﺛﺎﺑﺖ‪ c‬ﻭ ﺛﺎﺑﺖ ﺻﺤﻴﺢ ‪ no‬ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﮐﻪ‪:‬‬ ‫ﺗﻌﺮﻳﻒ‪:‬‬

‫)‪∀ n ≥ n0 : f (n) ≥ c g (n‬‬

‫) ‪c g (n‬‬
‫ﻣﺤﺪﻭﺩ ﮔﺮﺩﻳﺪﻩ ﺍﺳﺖ‪ .‬ﻭ ﺑﺪﻳﻦ ﺻـﻮﺭﺕ‬ ‫ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﮐﺮﺍﻥ ﭘﺎﻳﻴﻦ ﺗﻌﺪﺍﺩ ﺍﻋﻤﺎﻝ ﻻﺯﻡ ﺟﻬﺖ ﻳﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ‬

‫ﺧﻮﺍﻧﺪﻩ ﻣﻲ ﺷﻮﺩ‪ ( ) :‬ﺍﹸﻣﮕﺎﻱ ﺑﺰﺭﮒ ) ( ﺍﺳﺖ‪.‬‬

‫‪g n‬‬ ‫‪f n‬‬

‫‪f ( n ) ∈ θ  g ( n ) ‬‬
‫ﺍﮔﺮ ﻭ ﻓﻘﻂ ﺍﮔﺮ ﺛﺎﺑﺘﻬﺎﻱ ‪ c1‬ﻭ ‪ c 2‬ﻭ ﺛﺎﺑﺖ ﺻﺤﻴﺢ ‪ no‬ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺑﻪ ﮔﻮﻧﻪ ﺍﻱ ﮐﻪ ﺑـﺮﺍﻱ‬ ‫ﺗﻌﺮﻳﻒ‪:‬‬

‫ﻫﻤﻪ ﻣﻘﺎﺩﻳﺮ ‪ n ≥ no‬ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ‪.‬‬

‫)‪∀ n ≥ n0 : c1 g (n) ≤ f (n) ≤ c2 g (n‬‬

‫ﻗﻀﻴﻪ )‪:(١‬‬

‫) ‪Ο ( n m‬‬
‫‪‬‬
‫) ‪if f (n) = am n m + L + a1n + a0 then f (n) = Ω(n m‬‬
‫) ‪Θ(n m‬‬
‫‪‬‬
‫ﻗﻀﻴﻪ )‪:(٢‬‬

‫))‪f (n) = Ο( g (n)) ⇔ g (n) = Ω( f (n‬‬

‫‪١٠‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ﻗﻀﻴﻪ )‪:(٣‬‬
‫))‪ f (n) = O( g (n‬‬
‫‪f (n) = Θ( g (n)) ⇔ ‬‬
‫))‪ f (n) = Ω( g (n‬‬

‫ﺗﻌﺮﻳﻒ‪ f(n)∈o(g(n)) :‬ﺍﮔﺮ ﻭ ﻓﻘﻂ ﺍﮔﺮ ﺛﺎﺑﺖ‪ c‬ﻭ ﺛﺎﺑﺖ ‪ no‬ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ ﮐﻪ ﺑﺮﺍﻱ ﻫﻤﻪ ﻣﻘﺎﺩﻳﺮ ‪ ، n ≥ no‬ﺩﺍﺷـﺘﻪ‬
‫ﺑﺎﺷﻴﻢ‪:‬‬
‫| )‪∀n ≥ n0 :| f (n) | < c. | g (n‬‬
‫ﻧﻤﺎﺩ ‪ o‬ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﮔﻮﻧﻪ ﺩﻳﮕﺮﯼ ﻧﻴﺰ ﺗﻌﺮﻳﻒ ﮐﺮﺩ‪:‬‬
‫)‪f ( n‬‬
‫∞→‪f (n) = ο ( g (n)) ⇔ lim n‬‬ ‫‪=0‬‬
‫)‪g ( n‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪n‬‬
‫)‪= ο ( n‬‬
‫‪log n‬‬

‫ﺗﻌﺮﻳﻒ‪ f(n)∈ω(g(n)) :‬ﺍﮔﺮ ﻭ ﻓﻘﻂ ﺍﮔﺮ ﺛﺎﺑﺖ‪ c‬ﻭ ﺛﺎﺑﺖ ‪ no‬ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ ﮐﻪ ﺑﺮﺍﻱ ﻫﻤﻪ ﻣﻘﺎﺩﻳﺮ ‪ ، n ≥ no‬ﺩﺍﺷـﺘﻪ‬
‫ﺑﺎﺷﻴﻢ‪:‬‬
‫| )‪∀n ≥ n0 :| f (n) | > c. | g (n‬‬
‫ﻧﻤﺎﺩ ‪ ω‬ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﮔﻮﻧﻪ ﺩﻳﮕﺮﯼ ﻧﻴﺰ ﺗﻌﺮﻳﻒ ﮐﺮﺩ‪:‬‬
‫)‪f ( n‬‬
‫∞→‪f (n) = ω ( g (n)) ⇔ lim n‬‬ ‫∞=‬
‫)‪g ( n‬‬

‫ﻧﮑﺘﻪ‪ :‬ﻣﻘﺎﻳﺴﻪ ﻧﻤﺎﺩﻫﺎﯼ ﻣﺠﺎﻧﺒﯽ ﺩﻭ ﺗﺎﺑﻊ ‪ f‬ﻭ ‪ g‬ﺭﺍ ﺑﺎ ﺩﻭ ﻋﺪﺩ ﺣﻘﻴﻘﯽ ‪ a‬ﻭ ‪ b‬ﻣﻴﺘﻮﺍﻥ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺑﻴﺎﻥ ﮐﺮﺩ‪:‬‬
‫‪f (n) = Ο( g (n)) ≈ a ≤ b‬‬
‫‪f (n) = ο ( g (n)) ≈ a < b‬‬
‫‪f (n) = Ω( g (n)) ≈ a ≥ b‬‬
‫))‪f (n) = ω ( g (n‬‬ ‫‪≈ a>b‬‬
‫‪f (n) = Θ( g (n)) ≈ a = b‬‬

‫ﻧﮑﺘﻪ‪:‬‬
‫) ‪2 n ≠ Ο( 2 n‬‬
‫‪١١‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ﺍ‬ ‫ﻂ‬
‫‪۲‬‬ ‫‪۲‬‬

‫ﺘ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺳ‬ ‫ﻮ‬ ‫ﺘ‬ ‫ﻣ‬ ‫ﻟ‬ ‫ﺎ‬ ‫ﺣ‬ ‫ﻞ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻢ‬

‫ﺖ‬ ‫ﻴ‬ ‫ﻠ‬ ‫ﺤ‬

‫ﺗﺤﻠﻴﻞ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ﻳﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ﺍﻫﻤﻴﺖ ﺑﻴﺸﺘﺮﯼ ﻧﺴﺒﺖ ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﻭ ﺑﻬﺘـﺮﻳﻦ ﺣﺎﻟـﺖ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﻣﻴﺒﺎﺷـﺪ‪.‬‬
‫ﺍﮔﺮ ﺗﻌﺪﺍﺩ ﺗﮑﺮﺍﺭ ﻳﮏ ﺩﺳﺘﻮﺭﺍﻟﻌﻤﻞ ﺩﺭ ﻳﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎ ‪ n‬ﻭﺭﻭﺩﯼ ﺭﺍ ﺩﺭ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ﺑﺎ )‪ A(n‬ﻧﺸﺎﻥ ﺩﻫﻴﻢ ﺁﻧﮕﺎﻩ ﻳـﮏ‬
‫ﺭﺍﺑﻄﻪ ﺳﺎﺩﻩ ﺟﻬﺖ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻥ ﺣﺎﻟﺖ ﻣﺘﻮﺳﻂ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﻣﻴﺒﺎﺷﺪ‪:‬‬
‫) ‪A(n) = ∑ P(i ).F (i‬‬
‫‪i∈S‬‬

‫ﮐﻪ ﺩﺭ ﺁﻥ ‪ S‬ﻣﺠﻤﻮﻋﻪ ﺣﺎﻻﺕ ﻣﻤﮑﻨﻪ‪ P(i) ،‬ﺍﺣﺘﻤﺎﻝ ﺭﺥ ﺩﺍﺩﻥ ﺣﺎﻟﺖ ‪ i‬ﺍﻡ ﻭ )‪ F(i‬ﺗﻌﺪﺍﺩ ﺗﮑـﺮﺍﺭ ﺩﺳـﺘﻮﺭ ﻣـﻮﺭﺩ ﻧﻈـﺮ ﺩﺭ‬
‫ﺣﺎﻟﺖ ‪ i‬ﺍﻡ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﻣﺘﻮﺳﻂ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭﺍﻟﻌﻤﻞ )*( ﺭﺍ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‪:‬‬
‫)‪Procedure max (A,n,j‬‬
‫‪j
1‬‬
‫‪for i
2 to n do‬‬
‫‪if A(i) > A(j) then‬‬
‫‪j
i‬‬ ‫)*(‬
‫‪endif‬‬
‫‪repeat‬‬
‫‪end.‬‬
‫ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭ* ﺩﺭ ﻳﻚ ﺁﺭﺍﻳﻪ ‪ n‬ﺗﺎﻳﻲ ﺭﺍ ﺑﻄﻮﺭ ﻣﺘﻮﺳﻂ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ An‬ﺩﺭ ﻧﻈﺮ ﻣﻴﮕﻴﺮﻳﻢ ﻭ ﻟﺬﺍ‪:‬‬
‫‪0 ≤ An < n − 1‬‬

‫ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺳﺘﻮﺭ )*( ﺩﺭ ﺍﻳﻦ ﺯﻳﺮﺑﺮﻧﺎﻣﻪ ﺩﺭ ﺻﻮﺭﺗﻲ ﺻﻔﺮ ﺍﺳﺖ ﻛﻪ ﺑﺰﺭﮔﺘﺮﻳﻦ ﻋﻨﺼﺮ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﺁﺭﺍﻳﻪ ﺑﺎﺷﺪ‪.‬‬

‫‪ A1 = 0‬‬
‫‪‬‬
‫‪‬‬ ‫‪n −1‬‬ ‫‪1‬‬
‫) ‪ An = n An + n (1 + An−1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1 1‬‬
‫‪⇒ An = + An−1 = +‬‬ ‫‪+ L + + A1 = +‬‬ ‫)‪+ L + + − 1 = Θ(log n‬‬
‫‪n‬‬ ‫‪n n −1‬‬ ‫‪2‬‬ ‫‪−4‬‬
‫‪n 4n4‬‬
‫‪1‬‬ ‫‪1 2442431‬‬
‫‪= Hn‬‬
‫‪1‬‬
‫) ( ‪= ln n +γ + Θ‬‬
‫‪n‬‬
‫‪γ =0 5772‬‬

‫) ‪A (i ) > A ( j‬‬
‫ﺗﻌﺪﺍﺩ ﺗﮑﺮﺍﺭ ﺩﺳﺘﻮﺭ‬
‫‪( n − 1) + n ( n − 1) + n ( n − 1) + L + n ( n − 1) = n − 1‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪n‬‬
‫ﭘﺲ ﻫﻤﻴﺸﻪ ‪ n-1‬ﺑﺎﺭ ﺗﮑﺮﺍﺭ ﻣﻲ ﺷﻮﺩ‪.‬‬
١٢ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ ﻣﺘﻮﺳﻂ ﺗﻌﺪﺍﺩ ﺗﮑﺮﺍﺭ ﺩﺳﺘﻮﺭﺍﻟﻌﻤﻞ)*( ﺭﺍ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ؟‬:‫ﻣﺜﺎﻝ‬

Function Linear_search(A, n, x)
for i
1 to n do
if A(i)=x then (*)
return i
endif
repeat
end.
× 2 + × 3 + L + × n = × n = (1 + 2 + 3 + L + n )
1 1 1 1 1 1
×1 +
‫ = 
 ار‬n n n n n n

1 ( n + 1) n n + 1
⇒ =
n 2 2
‫ ﺍﺟﺮﺍ ﻣﻲ ﺷﺪ ﻭﻟﻲ ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﻫﺮﮔﺎﻩ ﮐﻪ ﺷﺮﻁ ﺑﺮﻗﺮﺍﺭ ﺑﺎﺷﺪ ﺍﺯ ﺣﻠﻘﻪ‬n ‫ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻗﺒﻠﻲ ﺩﺭ ﻫﺮ ﺻﻮﺭﺕ ﺣﻠﻘﻪ ﺗﺎ‬:‫ﻧﮑﺘﻪ‬
.‫ﺧﺎﺭﺝ ﻣﻲ ﺷﻮﻳﻢ‬
:‫ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‬QuickSort ‫ ﻣﻴﺎﻧﮕﻴﻦ ﺯﻣﺎﻥ ﺍﺟﺮﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ‬:‫ﻣﺜﺎﻝ‬
 0 ;n =1

T ( n) =  2 n−1
(n − 1) + ∑ T (i ) ; n > 1
 n i =1
2 n
⇒ T (n + 1) = n + ∑ T (i)
n + 1 i =1
n −1

 nT ( n ) = n ( n − 1) + 2 ∑ T (i )
⇒ i =1
n * (−1) +
(n + 1)T (n + 1) = n(n + 1) + 2∑ T (i )
 i =1

⇒ (n + 1)T (n + 1) − nT (n) = 2n + 2T (n)

⇒ (n + 1)T (n + 1) = 2n + (n + 2)T (n)
2n n + 2
⇒ T (n + 1) = + T ( n)
n +1 n +1
2n
n ≥1⇒ ≤2
}n+1 n+2
⇒ T (n + 1) ≤ 2 + T ( n)
n +1
n +1 n +1 n
⇒ T ( n) ≤ 2 + T (n − 1) ⇒ T (n) ≤ 2 + [2 + T (n − 2)]
n n n −1
n +1 n +1 n +1
⇒ T ( n) ≤ 2 +2 + T (n − 2)
n +1 n n −1
1 1 n +1 n −1
⇒ T (n) ≤ 2(n + 1)( + )+ [2 + T (n − 3)]
n + 1 n n −1 n−2
1 1 1 n +1
⇒ T (n) ≤ 2(n + 1)( + + )+ T (n − 3)
n + 1 n n −1 n − 2
1 1 1 1 n +1
⇒ T (n) ≤ 2(n + 1)( + + +L+ ) + T{(1)
n + 1 n
14444244443 n − 1 3 2 0
1
H n +1 − −1
2

⇒ T (n) = Ο(n. log n)

‫‪١٣‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ﻧﺘﻴﺠﻪ‪ :‬ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ ﻣﻴﺎﻧﮕﻴﻦ ﺯﻣﺎﻥ ﺍﺟﺮﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ QuickSort‬ﺑﺮﺍﺑﺮ )‪ O(n. log n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻣﺜـﺎﻝ‪ :‬ﻓــﺮﺽ ﮐﻨﻴـﺪ ﻳـﮏ ﺁﺭﺍﻳـﻪ ﻣﺮﺗـﺐ )ﺻـﻌﻮﺩﯼ( ﻭ ﮐﻠﻴــﺪ ‪ x‬ﺩﺍﺩﻩ ﺷـﺪﻩ ﺑﺎﺷـﻨﺪ‪ .‬ﻣﺘﻮﺳـﻂ ﺯﻣـﺎﻥ ﺍﺟـﺮﺍﯼ ﺍﻟﮕـﻮﺭﻳﺘﻢ‬
‫‪ BinarySearch‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﮐﻨﻴﺪ‪.‬‬
‫)‪Function BinarySearch( A, n, x‬‬
‫‪low ← 1‬‬
‫‪high←n‬‬
‫‪while low≤high do‬‬
‫‪mid←(low+high)/2‬‬
‫‪if x=A(mid) then‬‬
‫‪return mid‬‬
‫‪elsif x>A(mid) then‬‬
‫‪low←mid+1‬‬
‫‪else‬‬
‫‪high←mid-1‬‬
‫‪endif‬‬
‫‪repeat‬‬
‫‪return 0‬‬
‫‪end.‬‬
‫ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﮔﺮ ‪ x‬ﺩﺍﺧﻞ ﺁﺭﺍﻳﻪ ﻣﻮﺟﻮﺩ ﺑﺎﺷﺪ ﺗﻌﺪﺍﺩﯼ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳـﻪ ﺻـﻮﺭﺕ ﻣﻴﮕﻴـﺮﺩ ﻭ ﻧﻬﺎﻳﺘـﺎﹰ ﺟﺴـﺘﺠﻮ‬
‫ﻣﻮﻓﻖ ﺧﻮﺍﻫﺪ ﺑﻮﺩ ﻭ ﺍﮔﺮ ‪ x‬ﺩﺍﺧﻞ ﺁﺭﺍﻳﻪ ﻣﻮﺟﻮﺩ ﻧﺒﺎﺷﺪ‪ ،‬ﺗﻌﺪﺍﺩﯼ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﺻﻮﺭﺕ ﻣﻴﮕﻴﺮﺩ ﻭ ﻧﻬﺎﻳﺘﺎﹰ ﺟﺴـﺘﺠﻮ‬
‫ﻧﺎﻣﻮﻓﻖ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪ .‬ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺑﺼﻮﺭﺕ ﺟﺴﺘﺠﻮ ﺩﺭ ﻳﮏ ﺩﺭﺧﺖ ﺟﺴﺘﺠﻮﯼ ﺩﻭﺩﻭﻳﻲ ﺍﻧﺠﺎﻡ ﻣﻴﺸﻮﻧﺪ ﺑﺮﺍﯼ ﻧﻤﻮﻧﻪ ﺑﻪ ﺁﺭﺍﻳﻪ‬
‫ﺯﻳﺮ ﻭ ﺩﺭﺧﺖ ﺣﺎﺻﻞ ﺍﺯ ﺟﺴﺘﺠﻮﯼ ﺁﻥ ﺩﻗﺖ ﮐﻨﻴﺪ‪:‬‬
‫‪A‬‬ ‫‪1 2 3 4 5 6 7 8 9‬‬
‫ﻣﻘﺎﺩﻳﺮ‬ ‫‪6 10 16 19 21 42 66 81 93‬‬
‫‪ 3 2‬ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﺎﺕ ﺩﺭ ﺣﺎﻟﺖ ﻣﻮﻓﻖ‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬

‫‪5‬‬

‫‪2‬‬ ‫‪7‬‬

‫‪1‬‬ ‫‪3‬‬ ‫‪6‬‬ ‫‪8‬‬

‫‪9‬‬
‫‪4‬‬
‫‪١٤‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ﺩﺭ ﺩﺭﺧﺖ ﺑﺎﻻ ﮔﺮﻩ ﻫﺎﯼ ﺧﺎﺭﺟﯽ ﺑﺎ ﻣﺴﺘﻄﻴﻞ ﻭ ﮔﺮﻩ ﻫﺎﯼ ﺩﺍﺧﻠﯽ ﺑﺎ ﺩﺍﻳﺮﻩ ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﺷـﺪﻩ ﺍﻧـﺪ‪.‬ﺩﺭﺧـﺖ ﺑـﺎﻻ ﺭﺍ ﺩﺭﺧـﺖ‬
‫ﺗﺼﻤﻴﻢ ﺩﻭﺩﻭﻳﻲ ﻣﻴﻨﺎﻣﻨﺪ‪ .‬ﺟﺴﺘﺠﻮﻫﺎﯼ ﻣﻮﻓﻖ ﺑﻪ ﮔﺮﻩ ﻫﺎﯼ ﺩﺍﺧﻠﯽ ﻭ ﺟﺴﺘﺠﻮﻫﺎﯼ ﻧﺎﻣﻮﻓﻖ ﺑـﻪ ﮔـﺮﻩ ﻫـﺎﯼ ﺧـﺎﺭﺟﯽ ﺧـﺘﻢ‬
‫ﻣﻴﺸﻮﻧﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺍﮔﺮ ﺗﻌﺪﺍﺩ ﮔﺮﻩ ﻫﺎﯼ ﺧﺎﺭﺟﯽ ﺭﺍ ﺑﺎ ‪ n0‬ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﻭ ﺗﻌﺪﺍﺩ ﮔﺮﻩ ﻫﺎﯼ ﺩﺍﺧﻠﯽ ﺭﺍ ﺑﺎ ‪ n‬ﻧﺸﺎﻥ ﺩﻫﻴﻢ ﺁﻧﮕﺎﻩ ‪n0=n+1‬‬
‫‪=(3+2+3+4+1+3+2+3+4)/9=25/9=2.77‬ﻣﻴﺎﻧﮕﻴﻦ ﺟﺴﺘﺠﻮﻫﺎﯼ ﻣﻮﻓﻖ‬

‫ﻧﮑﺘﻪ‪ :‬ﻓﺮﺽ ﮐﻨﻴﺪ ﺍﺣﺘﻤﺎﻝ ﻣﻮﺟﻮﺩ ﺑﻮﺩﻥ ‪ x‬ﺩﺍﺧﻞ ﻋﻨﺎﺻﺮ ﻣﺨﺘﻠﻒ ﺁﺭﺍﻳﻪ ﻭ ﻫﻤﭽﻨﻴﻦ ﺩﺭ ﺻﻮﺭﺕ ﻣﻮﺟﻮﺩ ﻧﺒﻮﺩﻥ ‪ x‬ﺩﺭ ﺁﺭﺍﻳﻪ‬
‫ﺍﺣﺘﻤﺎﻝ ﻗﺮﺍﺭ ﺩﺍﺷﺘﻦ ‪ x‬ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ﻣﺴﺎﻭﯼ ﺍﺳﺖ)ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﺍﺣﺘﻤﺎﻝ ﻗـﺮﺍﺭ ﺩﺍﺷـﺘﻦ ‪ x‬ﺩﺭ ﻣﺠﻤﻮﻋـﻪ ]‪ [5,9‬ﻭ‬
‫]‪ [11,15‬ﻭ ‪ ...‬ﻣﺴﺎﻭﯼ ﺍﺳﺖ)ﮐﻼﺳﻬﺎ ﻣﺘﺴﺎﻭﯼ ﺍﻻﺣﺘﻤﺎﻟﻨﺪ(‪.‬‬
‫‪A‬‬ ‫‪1 2 3 4‬‬ ‫‪5‬‬ ‫‪6 7 8 9‬‬
‫‪ 3 3 3 4 4 3 3 3 4 4‬ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﺎﺕ ﺩﺭ ﺣﺎﻟﺖ ﻧﺎﻣﻮﻓﻖ‬
‫‪=(3+3+3+4+4+3+3+3+4+4)/10=37/10=3.7‬ﻣﻴﺎﻧﮕﻴﻦ ﺟﺴﺘﺠﻮﻫﺎﯼ ﻧﺎﻣﻮﻓﻖ‬
‫ﻗﻀﻴﻪ‪ :‬ﺍﮔﺮ )‪ n∈[2k-1,2k‬ﺑﺎﺷﺪ‪ ،‬ﺁﻧﮕﺎﻩ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺟﺴﺘﺠﻮﯼ ﺩﻭﺩﻭﻳﻲ ﻣﺴﺘﻠﺰﻡ ﺣﺪﺍﮐﺜﺮ ‪ k‬ﻣﻘﺎﻳﺴﻪ ﺑﺮﺍﯼ ﺟﺴﺘﺠﻮﯼ ﻣﻮﻓـﻖ‬
‫ﻭ ‪ k-1‬ﻳﺎ ‪ k‬ﻣﻘﺎﻳﺴﻪ ﺑﺮﺍﯼ ﺟﺴﺘﺠﻮﯼ ﻧﺎﻣﻮﻓﻖ ﺍﺳﺖ‪.‬‬
‫ﻧﺘﻴﺠﻪ‪ :‬ﺟﺴﺘﺠﻮﯼ ﻧﺎﻣﻮﻓﻖ ﺩﺍﺭﺍﯼ ﻫﻤﻴﺸﻪ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ Θ(log n‬ﺍﺳﺖ‪ .‬ﺟﺴﺘﺠﻮﯼ ﻣﻮﻓـﻖ ﺩﺭ ﺑﻬﺘـﺮﻳﻦ ﻭﺿـﻌﻴﺖ‬
‫)‪ Ω(1‬ﻭ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭﺿﻌﻴﺖ )‪ O(log n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﺣﺎﻝ ﻣﺘﻮﺳﻂ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﺎﺕ ﺩﺭ ﺟﺴﺘﺠﻮﯼ ﻣﻮﻓﻖ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻣﻴﮑﻨﻴﻢ‪:‬‬
‫ﺍﮔﺮ ‪ v‬ﻳﮏ ﮔﺮﻩ ﺩﺍﺧﻠﯽ ﺩﺭ ﺩﺭﺧﺖ ﺗﺼﻤﻴﻢ ﺑﺎﺷﺪ ﻭ ﺳﻄﺢ ﺁﻥ ﺭﺍ ﺑﺎ )‪ Level(v‬ﻧﺸﺎﻥ ﺩﻫﻴﻢ‪ ،‬ﺁﻧﮕﺎﻩ ﺗﻌﺮﻳﻒ ﻣﻴﮑﻨﻴﻢ‪:‬‬
‫‪d (v) = level (v) − 1‬‬
‫=‪E‬‬ ‫) ‪∑ d (v‬‬
‫‪v∈External Nodes‬‬

‫=‪I‬‬ ‫) ‪∑ d (v‬‬
‫‪v∈Internal Nodes‬‬

‫ﻗﻀﻴﻪ‪E=I+2n :‬‬
‫ﺭﺍﻫﻨﻤﺎﻳﻲ ﺍﺛﺒﺎﺕ‪ :‬ﺑﺎ ﺍﺳﺘﻘﺮﺍ ﺍﺛﺒﺎﺕ ﮐﻨﻴﺪ‪.‬‬
‫ﺣﺎﻝ ﺍﮔﺮ ﻣﻴﺎﻧﮕﻴﻦ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﺎﺕ ﺩﺭ ﺟﺴﺘﺠﻮﯼ ﻣﻮﻓﻖ ﺩﺭ ﻳﮏ ﺩﺭﺧﺖ ﺗﺼﻤﻴﻢ ﺑﺎ ‪ n‬ﮔﺮﻩ ﺩﺍﺧﻠﯽ ﺭﺍ ﺑﺎ )‪ S(n‬ﻭ ﻣﻴـﺎﻧﮕﻴﻦ‬
‫ﻣﻘﺎﻳﺴﺎﺕ ﺩﺭ ﺟﺴﺘﺠﻮﯼ ﻧﺎﻣﻮﻓﻖ ﺭﺍ ﺑﺎ )‪ U(n‬ﻧﺸﺎﻥ ﺩﻫﻴﻢ‪ ،‬ﺁﻧﮕﺎﻩ‪:‬‬
‫]‪∑[d (v) + 1‬‬
‫‪v∈Internal Nodes‬‬ ‫‪I +n‬‬
‫= )‪S ( n‬‬ ‫=‬
‫‪n‬‬ ‫‪n‬‬
‫) ‪∑ d (v‬‬
‫‪v∈External Nodes‬‬ ‫‪E‬‬
‫= )‪U ( n‬‬ ‫=‬
‫‪n +1‬‬ ‫‪n +1‬‬
‫ﺣﺎﻝ ﺑﺎ ﺍﺳﺘﻨﺎﺩ ﺑﻪ ﻗﻀﻴﻪ ﺑﺎﻻ ﻭ ﺩﻭ ﺭﺍﺑﻄﻪ ﺑﻪ ﺩﺳﺖ ﺁﻣﺪﻩ ﻣﻴﺘﻮﺍﻥ ﻧﺘﻴﺠﻪ ﮔﺮﻓﺖ ﮐﻪ‪:‬‬
‫‪E − 2n + n (n + 1)U (n) − n‬‬ ‫‪1‬‬
‫= )‪⇒ S ( n‬‬ ‫=‬ ‫‪= (1 + )U (n) − 1‬‬
‫‪n‬‬ ‫‪n‬‬ ‫‪n‬‬
‫ﻼ ﺩﻳﺪﻳﻢ ﮐﻪ )‪ U(n)=Θ(log n‬ﺩﺭ ﻧﺘﻴﺠﻪ‪:‬‬
‫ﻭ ﭼﻮﻥ ﻗﺒ ﹰ‬
‫)‪S (n) = Θ(log n‬‬
‫‪١٥‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫ﻂ‬ ‫ﺍ‬

‫‪۳‬‬ ‫‪۲‬‬

‫ﺘ‬ ‫ﺸ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺑ‬ ‫ﺑ‬ ‫ﻭ‬ ‫ﺭ‬

‫‪-‬‬ ‫‪-‬‬

‫ﯽ‬ ‫ﮔ‬

‫ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﻃﻮﺭ ﻣﺨﺘﺼﺮ ﺍﺯ ﺣﻞ ﺭﻭﺍﺑﻂ ﺑﺎﺯﮔﺸﺘﯽ ﺳﺨﻦ ﺧﻮﺍﻫﻴﻢ ﮔﻔﺖ‪ .‬ﺭﻭﺍﺑﻂ ﺑﺎﺯﮔﺸﺘﯽ ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺍﺯ ﺭﻭﯼ ﺩﺭﺟـﻪ‬
‫ﺁﻥ ﺩﺳﺘﻪ ﺑﻨﺪﯼ ﮐﺮﺩ‪:‬‬

‫‪۱‬‬ ‫‪۱‬‬ ‫‪۳‬‬ ‫‪۲‬‬

‫ﻪ‬

‫ﺯ‬ ‫ﺎ‬ ‫ﺑ‬ ‫ﻂ‬ ‫ﺑ‬

‫ﺘ‬ ‫ﺸ‬ ‫ﮔ‬ ‫ﻭ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺟ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﯽ‬ ‫ﺍ‬ ‫ﺭ‬

‫ﺍﻳﻦ ﺭﻭﺍﺑﻂ ﺑﻪ ﺳﺎﺩﮔﯽ ﺍﺯ ﻃﺮﻳﻖ ﺭﻭﺵ ﺟﺎﻳﮕﺬﺍﺭﯼ ﻗﺎﺑﻞ ﺣﻞ ﻣﻴﺒﺎﺷﻨﺪ‪ .‬ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﺑﺎ ﺑﺎﺯ ﮐﺮﺩﻥ ﺭﺍﺑﻄﻪ ﺑﺼﻮﺭﺕ ﺗـﻮ ﺩﺭ‬
‫ﺗﻮ ﻣﻴﺘﻮﺍﻥ ﺭﺍﺑﻄﻪ ﺭﺍ ﺣﻞ ﻧﻤﻮﺩ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪2T (n − 1) + 1 ; n > 0‬‬
‫‪T ( n) = ‬‬
‫‪‬‬ ‫‪1‬‬ ‫‪;n = 0‬‬
‫‪⇒ T (n) = 2T (n − 1) + 1‬‬
‫‪= 2[2T (n − 2) + 1] + 1 = 4T (n − 2) + 2 + 1 = 2 2 T (n − 2) + 21 + 2 0‬‬
‫‪= 2 i T (n − i ) + 2 i −1 + L + 21 + 2 0‬‬
‫‪n‬‬
‫) ‪= 2 n T (0) + 2 n−1 + L + 2 0 = ∑ 2i = 2 n+1 − 1 = Ο(2 n‬‬
‫‪i =0‬‬

‫(‬ ‫)‬

‫‪۲‬‬ ‫‪۲‬‬ ‫‪۳‬‬ ‫‪۲‬‬

‫ﻪ‬

‫ﻤ‬ ‫ﻫ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺑ‬ ‫ﻂ‬ ‫ﺑ‬

‫ﻦ‬

‫ﺘ‬ ‫ﺸ‬ ‫ﮔ‬ ‫ﻭ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﮕ‬ ‫ﺟ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﯽ‬ ‫ﺍ‬ ‫ﺭ‬

‫ﺍﻳﻦ ﺭﻭﺍﺑﻂ ﺑﻪ ﺭﻭﺵ ﻣﺤﺴﺒﻪ ﻣﻌﺎﺩﻟﻪ ﻣﺸﺨﺼﻪ ﻗﺎﺑﻞ ﺣﻞ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺗﻌﺪﺍﺩ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻫﺎﻱ ﺗﺎﺑﻊ ﻣﻘﺎﺑﻞ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ؟‬
‫)‪function f(n‬‬
‫‪if n<2 then‬‬
‫‪return n‬‬
‫‪else‬‬
‫)‪return f(n-1)+f(n-2‬‬
‫‪end if‬‬
‫‪end.‬‬
‫‪ =An‬ﺗﻌﺪﺍﺩ ﻓﺮﺍﺧﻮﺍﻧﻲ ﻫﺎﻱ ﺗﺎﺑﻊ ‪ f‬ﺑﺎ ﻭﺭﻭﺩﻱ ‪n‬‬
‫‪A n = A n −1 + A n − 2 + 1‬‬
‫‪‬‬
‫‪A 0 = 1‬‬
‫‪A = 1‬‬
‫‪ 1‬‬
‫ﺭﺍﻩ ﺣﻞ‪:‬‬
‫‪١٦‬‬ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

‫‪A n = A n −1 + A n − 2 + 1‬‬
‫‪A n + 1 = A n −1 + A n − 2 + 1 + 1‬‬
‫‪*B n = A n + 1‬‬
‫‪* ⇒ B n = B n −1 + B n − 2‬‬
‫‪B0 = 2‬‬ ‫‪B1 = 2‬‬
‫‪n‬‬ ‫‪n‬‬ ‫‪n −1‬‬ ‫‪n −2‬‬
‫‪Bn = r ⇒ r‬‬ ‫‪=r‬‬ ‫‪+r‬‬
‫‪r 2 − r −1 = 0‬‬
‫‪1+ 5‬‬ ‫‪1− 5‬‬
‫= ‪r1‬‬ ‫= ‪r2‬‬
‫‪2‬‬ ‫‪2‬‬
‫‪B n = C1r1n + C 2r2n‬‬
‫⇒‬ ‫‪B 0 = C1r10 + C 2r20 = C1 + C 2 = 2‬‬
‫‪if‬‬ ‫‪n=0‬‬ ‫‪1‬‬
‫‪ 1+ 5 ‬‬ ‫‪ 1− 5 ‬‬
‫⇒‬ ‫‪B1 = C1r11 + C 2 r21 = C1 ‬‬ ‫‪+C2 ‬‬ ‫‪=2‬‬
‫‪ 2 ‬‬ ‫‪ 2 ‬‬
‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪if‬‬ ‫‪n=1‬‬ ‫‪2‬‬
‫‪1+ 5‬‬ ‫‪1− 5‬‬
‫⇒‬ ‫= ‪C1‬‬ ‫= ‪C2‬‬
‫‪2‬و‪1‬‬ ‫‪5‬‬ ‫‪5‬‬

‫‪‬‬ ‫‪n +1‬‬ ‫‪n +1 ‬‬

‫‪2  1 + 5 ‬‬ ‫‪ 1− 5 ‬‬ ‫‪‬‬
‫= ‪Bn‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪−‬‬ ‫‪‬‬
‫‪5  2 ‬‬ ‫‪ 2 ‬‬ ‫‪‬‬
‫‪‬‬ ‫‪‬‬ ‫‪‬‬ ‫‪‬‬
‫) ‪A n = B n − 1 ≅ (1/ 6‬‬
‫‪n‬‬

‫ﺭﻭﺵ ﺣﻞ ﭘﺮﻭﺳﻴﺠﺮ ﻗﺒﻠﻲ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﻣﻴﺒﺎﺷﺪ ﻭ ﻳﮏ ﺩﺭﺧﺖ ﺭﺍ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﭘﻮﻳﺶ ﻣﻲ ﮐﻨﺪ ﺍﻳﻦ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﻣﻘـﺎﺩﻳﺮﻱ‬
‫ﺭﺍ ﭼﻨﺪﻳﻦ ﺑﺎﺭ ﺑﺼﻮﺭﺕ ﺗﮑﺮﺍﺭﯼ ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﮐﻨﺪ ﻭ ﺑﻪ ﻫﻤﻴﻦ ﻋﻠﺖ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﻤﺎﺋﻲ ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ ﺩﺭﺧﺖ ﻓﺮﺍﺧﻮﺍﻧﯽ )‪: f(5‬‬

‫)‪f(5‬‬

‫)‪f(3‬‬
‫)‪f(4‬‬

‫)‪f(3‬‬ ‫)‪f(2‬‬ ‫)‪f(1‬‬ ‫)‪f(2‬‬

‫)‪f(2‬‬ ‫)‪f(1) f(1‬‬ ‫)‪f(0‬‬ ‫)‪f(1‬‬ ‫)‪f(0‬‬

‫)‪f(1‬‬ ‫)‪f(0‬‬

‫ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺭﺍ ﺑﻪ ﻭﺳﻴﻠﻪ ﻳﻚ ﺣﻠﻘﻪ ﺑﺮﮒﻫﺎ ﺑﻪ ﺳﻤﺖ ﺭﻳﺸﻪ ﺑﺎ ﺣﻔﻆ ﻣﻘﺎﺩﻳﺮ ﻫﻢ ﻣﻲﺗﻮﺍﻥ ﺣﻞ ﻛﺮﺩ ﻛﻪ ﺍﻳﻦ ﺭﻭﺵ ﭘـﺎﻳﻴﻦ ﺑـﻪ‬
‫ﺑﺎﻻ )‪ (bottom-up‬ﺍﺳﺖ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺣﺎﻟﺖﻫﺎﻱ ﺗﻜﺮﺍﺭﻱ ﺣﺬﻑ ﻣﻲﺷﻮﺩ‪) .‬ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ(‬

‫)‪(Master Theorem‬‬
‫ﺍ‬ ‫ﻪ‬
‫‪٤‬‬ ‫‪٢‬‬

‫‪-‬‬ ‫‪-‬‬

‫ﻲ‬ ‫ﻠ‬ ‫ﺻ‬ ‫ﻴ‬ ‫ﻀ‬ ‫ﻗ‬

‫ﺩﺭ ﻓﺼﻞ ﺑﻌﺪﯼ ﺑﺎ ﻳﮑﯽ ﺍﺯ ﺭﻭﺷﻬﺎﯼ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﻪ ﻧﺎﻡ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﺁﺷﻨﺎ ﺧﻮﺍﻫﻴﻢ ﺷﺪ ﮐﻪ ﺩﺭ ﺗﺤﻠﻴﻞ ﻣﺮﺗﺒﻪ ﺯﻣـﺎﻧﯽ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﻃﺮﺍﺣﯽ ﺷﺪﻩ ﺑﻪ ﺁﻥ ﺭﻭﺵ ﺑﻪ ﻗﻀﻴﻪﺍﯼ ﺑﻪ ﻧﺎﻡ ﻗﻀﻴﻪ ﺍﺻﻠﯽ ﻧﻴﺎﺯ ﺧﻮﺍﻫﻴﻢ ﺩﺍﺷﺖ ﻭ ﻟﺬﺍ ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﺑﻴﺎﻥ‬
‫ﺁﻥ ﺧﻮﺍﻫﻴﻢ ﭘﺮﺩﺍﺧﺖ‪.‬‬
١٧ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

:‫ﻗﻀﻴﻪ ﺍﺻﻠﯽ‬
T ( n ) = aT ( ) + Cn k
n
b if
:‫ ﺍﺳﺖ ﺁﻧﮕﺎﻩ‬b>1 ‫ ﺍﻋﺪﺍﺩ ﺛﺎﺑﺖ ﻭ‬k‫ ﻭ‬c,a,b ‫ﻛﻪ ﺩﺭ ﺁﻥ‬
  logba 
θ  n  a >bk
  

( )
T ( n ) = θ n k log n

a =bk



( )
θ n k a <bk

:‫ﻣﺜﺎﻝ‬
.‫ ﺭﺍ ﺑﻪ ﻛﻤﻚ ﻗﻀﻴﻪ ﺍﺻﻠﻲ ﺑﻪ ﺩﺳﺖ ﺁﻭﺭﻳﺪ‬Binary search ‫ﺯﻣﺎﻥ ﺍﺟﺮﺍﻱ‬
n
T ( n ) = 1 +T  
2

a = 1

b = 2 a = b k ⇒ 1 = 20

( )

k = 0 θ n k log n = θ ( log n )

.‫ ﺩﺭ ﺯﻣﺎﻥ ﻧﻬﺎﻳﻲ ﺗﺄﺛﻴﺮﻱ ﻧﺪﺍﺭﺩ‬c ‫ ﺩﺭ ﻗﻀﻴﻪ ﺍﺻﻠﻲ ﻣﻘﺪﺍﺭ‬:‫ﻧﻜﺘﻪ‬
‫ ﺯﻣﺎﻥ ﺍﺟﺮﺍﻱ ﻣﺜﺎﻝﻫﺎﻱ ﺯﻳﺮ ﺭﺍ ﺑﻪ ﻛﻤﻚ ﻗﻀﻴﻪ ﺍﺻﻠﻲ ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﺪ؟‬:‫ﻣﺜﺎﻝ‬
3n
T (n) = T ( ) + n2 ⇒
2

a = 1

 2
b = a <bk
 3
k = 2
 ( ) ( )
θ nk =θ n2

:‫ﻣﺜﺎﻝ‬
T ( n ) = 2T ( n ) + log n
n = 2m ⇒ m = log n2

 m 
( )
T 2m = T  2 2

+m


 

( )
T 2m = s ( m )

m 
s ( m ) = 2s  +m
 2 
θ ( m log m ) , ⇒ θ ( log n .log log n )

:‫ﻣﺜﺎﻝ‬
١٨ ‫ﺗﺤﻠﻴﻞ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎ‬

n 
T ( n ) = 3T   + n log n
4
a = 3 n log n = n 1/ x n < n log n < n 2


b = 4

( )
θ n1/ x = θ ( n log n )
k = 1/ x

 ‫‪۳‬‬

‫)‪(Greedy‬‬ ‫ﻪ‬ ‫ﻧ‬

‫ﺎ‬ ‫ﺼ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺣ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬ ‫‪-‬‬

‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‪ ،‬ﺭﻭﺵ ﺁﺯﻣﻨﺪ ﻭ ﻳﺎ ﺭﻭﺵ ﺩﺳﺘﺎﻭﺭﺩﻫﺎﻱ ﻗﺪﻡ ﺑﻪ ﻗﺪﻡ ﻧﻴﺰ ﻧﺎﻣﻴﺪﻩ ﻣﻲﺷﻮﺩ‪ .‬ﺍﻳﻦ ﺭﻭﺵ ﺟﺰﻭ ﺭﺩﻩ ﺑﺰﺭﮔﺘﺮﻱ ﺑﻪ‬
‫ﻧﺎﻡ ﺭﻭﺷﻬﺎﻱ ﺑﻬﻴﻨﻪﺳﺎﺯﻱ ﺍﺳﺖ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ‪:‬‬
‫‪ -۱‬ﺩﻧﺒﺎﻟﻪﺍﯼ ﺍﺯ ﺍﻧﺘﺨﺎﺑﻬﺎ ﺭﺍ ﺩﺭ ﭘﻴﺶ ﺭﻭ ﺩﺍﺭﻳﻢ ﮐﻪ ﺑﺎﻳﺪ ﺍﺯ ﺑﻴﻦ ﺍﻳﻦ ﺩﻧﺒﺎﻟﻪ ﺍﻧﺘﺨﺎﺑﻬﺎﻳﻲ ﺭﺍ ﮐـﻪ ﻣﻨﺠـﺮ ﺑـﻪ ﺑﻬﻴﻨـﻪ ﺷـﺪﻥ‬
‫ﺟﻮﺍﺏ ﻧﻬﺎﻳﻲ ﮔﺮﺩﺩ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﻢ‪.‬‬
‫‪ -۲‬ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﺍﺯ ﻣﺮﺍﺣﻞ ﺍﺟﺮﺍﻳﻲ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺑﺎﻳـﺪ ﺑﺨﺸـﻲ ﺍﺯ ﺟـﻮﺍﺏ ﻳـﺎ ﺑـﻪ ﻋﺒـﺎﺭﺕ ﺩﺭﺳـﺖﺗـﺮ ﻣﺆﻟﻔـﻪﺍﻱ ﺍﺯ‬
‫ﻣﺆﻟﻔﻪﻫﺎﻱ ﺟﻮﺍﺏ ﺭﺍ ﺑﻪ ﺩﺳﺖ ﺁﻭﺭﻳﻢ‪.‬‬
‫‪ -۳‬ﻧﺘﻴﺠﻪ ﻧﻬﺎﻳﻲ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺁﺯﻣﻨﺪ ﻣﺠﻤﻮﻋﻪﺍﻱ ﺍﺯ ﺩﺍﺩﻩﻫﺎﺳﺖ ﻛﻪ ﻣﻤﻜﻦ ﺍﺳﺖ ﺗﺮﺗﻴﺐ ﺁﻧﻬﺎ ﻧﻴـﺰ ﺍﻫﻤﻴـﺖ ﺩﺍﺷـﺘﻪ‬
‫ﺑﺎﺷﺪ‪ .‬ﺍﻳﻦ ﻣﺠﻤﻮﻋﻪ ﺩﺍﺩﻩﻫﺎ ﺑﻴﺸﺘﺮ ﻣﻮﺍﻗﻊ ﺯﻳﺮﻣﺠﻤﻮﻋﻪ ﺩﺍﺩﻩﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺍﺳﺖ‪.‬‬
‫‪ -۴‬ﺟﻮﺍﺏ ﻧﻬﺎﻳﻲ ﺑﺎﻳﺪ ﺗﺎﺑﻊ ﻫﺪﻑ ﻳﻚ ﻋﺒﺎﺭﺕ ﺭﺍ ﺑﻬﻴﻨﻪ )ﻣﺎﻛﺰﻳﻤﻢ ﻭ ﻳﺎ ﻣﻴﻨﻴﻤﻢ( ﻧﻤﺎﻳﺪ‪ .‬ﺍﻟﺒﺘـﻪ ﺑﺎﺗﻮﺟـﻪ ﺑـﻪ ﺍﻳﻨﻜـﻪ ﺩﺭ‬
‫ﺭﻭﺵﻫﺎﻱ ﺁﺯﻣﻨﺪ ﺁﻳﻨﺪﻩﻧﮕﺮﻱ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﻭ ﺑﻪ ﻭﺿﻌﻴﺖ ﺟﺎﺭﻱ ﺑﻴﺸﺘﺮ ﺗﻮﺟﻪ ﻣﻲﺷﻮﺩ ﻭﺍﺿـﺢ ﺍﺳـﺖ ﻛـﻪ ﺍﻳـﻦ‬
‫ﺑﻬﻴﻨﮕﻲ ﻣﻤﮑﻦ ﺍﺳﺖ ﻛﻠﻲ ﻧﺒﺎﺷﺪ ﻭ ﻣﺤﻠﻲ ﺑﺎﺷﺪ ﻭ ﺑﻪ ﻋﺒﺎﺭﺗﻲ ‪ max‬ﻭ ‪ min‬ﻓﻌﻠﻲ ﺣﺎﺻﻞ ﻣﻲﺷﻮﺩ ﻧﻪ ﻣﺎﻛﺰﻳﻤﻢ‬
‫ﻭ ﻣﻴﻨﻴﻤﻢ ﺳﺮﺍﺳﺮﯼ‪.‬‬
‫‪ -۵‬ﺗﺼﻤﻴﻢ ﺍﺗﺨﺎﺫ ﺷﺪﻩ ﺩﺭ ﻣﻮﺭﺩ ﺍﻧﺘﺨﺎﺏ ﻳﺎ ﻋﺪﻡ ﺍﻧﺘﺨﺎﺏ ﻳﻜﻲ ﺍﺯ ﺩﺍﺩﻩﻫﺎﻱ ﻭﺭﻭﺩﻱ ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺆﻟﻔـﻪﺍﻱ ﺍﺯ ﺟـﻮﺍﺏ‪،‬‬
‫ﻗﻄﻌﻲ ﻭ ﻏﻴﺮﻗﺎﺑﻞ ﺑﺮﮔﺸﺖ ﺍﺳﺖ‪.‬‬
‫‪ -۶‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﻳﺪ ﺑﺼﻮﺭﺕ ﻣﺤﻠﯽ ﺑﻬﺘﺮﻳﻦ ﺍﻧﺘﺨﺎﺏ ﺭﺍ ﺍﻧﺠﺎﻡ ﺩﺍﺩ ﻭ ﺍﻣﻴﺪﻭﺍﺭ ﺑـﻮﺩ ﮐـﻪ ﺑﻬﺘـﺮﻳﻦ ﺍﻧﺘﺨـﺎﺏ ﻣﺤﻠـﯽ‬
‫ﻣﻨﺠﺮ ﺑﻪ ﺑﻬﺘﺮﻳﻦ ﺍﻧﺘﺨﺎﺏ ﺳﺮﺍﺳﺮﯼ ﻧﻴﺮ ﺧﻮﺍﻫﺪ ﺷﺪ ) ﺍﮔﺮ ﺑﺘﻮﺍﻥ ﺍﻳﻦ ﻣﻮﺿﻮﻉ ﺭﺍ ﺍﺛﺒﺎﺕ ﮐﺮﺩ ﻣﻴﺘﻮﺍﻥ ﻣﺴﺌﻠﻪ ﺭﺍ ﺑـﻪ‬
‫ﺍﻳﻦ ﺭﻭﺵ ﺣﻞ ﮐﺮﺩ(‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺴﺌﻠﻪ ﻣﻬﻢ ﺩﺭ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ ﺍﺛﺒﺎﺕ ﻣﻮﺭﺩ ﭘﻨﺠﻢ ﺍﺯ ﻣﻮﺍﺭﺩ ﺑﺎﻻ ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﺍﺟﺰﺍﻱ ﺍﻟﮕﻮﺭﻳﺘﻢﻫﺎﻱ ﺣﺮﻳﺼﺎﻧﻪ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ‪:‬‬

‫‪ -١‬ﻣﺠﻤﻮﻋﻪ ﺍﻭﻟﻴﻪ ﻛﻪ ﻣﺆﻟﻔﻪﻫﺎﻱ ﺟﻮﺍﺏ ﺍﺯ ﺑﻴﻦ ﺁﻧﻬﺎ ﺍﻧﺘﺨﺎﺏ ﻣﻲﺷﻮﺩ‪.‬‬
‫‪ -٢‬ﻣﺠﻤﻮﻋﻪ ﻣﺆﻟﻔﻪﻫﺎﻳﻲ ﻛﻪ ﺗﺎ ﺑﻪ ﺣﺎﻝ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩﺍﻧﺪ )ﺑﻪ ﻋﻨﻮﺍﻥ ﺑﺨﺸﻲ ﺍﺯ ﺟﻮﺍﺏ(‪.‬‬
‫‪ -٣‬ﺗﺎﺑﻌﻲ ﺑﺮﺍﻱ ﺍﻧﺘﺨﺎﺏ ﻣﺆﻟﻔﻪ ﺑﻌﺪﻱ‪.‬‬
‫‪ -٤‬ﺗﺎﺑﻌﻲ ﺑﺮﺍﻱ ﺗﻌﻴﻴﻦ ﺍﻳﻨﻜﻪ ﺑﺎ ﺍﻧﺘﺨﺎﺏ ﺟﺎﺭﻱ ﻭ ﻣﺠﻤﻮﻋﻪ ﺍﻧﺘﺨﺎﺏﻫﺎﻱ ﻗﺒﻠﻲ ﺍﻣﻜﺎﻥ ﺭﺳـﻴﺪﻥ ﺑـﻪ ﺟـﻮﺍﺏ ﻭﺟـﻮﺩ ﺩﺍﺭﺩ ﻳـﺎ‬
‫ﺧﻴﺮ‪.‬‬
‫‪٢٠‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫‪ -٥‬ﺗﺎﺑﻊ ﻫﺪﻑ ﺑﺮﺍﻱ ﺍﺭﺯﺵ ﺩﻫﻲ ﺑﻪ ﺟﻮﺍﺏ ﻣﺴﺄﻟﻪ ﻛﻪ ﻫﺪﻑ ﻧﻬﺎﻳﻲ ﺑﻬﻴﻨﻪ ﻛﺮﺩﻥ ﺍﻳﻦ ﺗﺎﺑﻊ ﺍﺳﺖ‪.‬‬
‫‪ -٦‬ﻳﻚ ﺗﺎﺑﻊ ﺑﺮﺍﻱ ﺑﺮﺭﺳﻲ ﺍﻳﻨﻜﻪ ﻣﺸﺨﺺ ﻛﻨﺪ ﺩﺭ ﻧﻬﺎﻳﺖ ﺟﻮﺍﺏ ﺣﺎﺻﻞ ﺷﺪﻩ ﻳﺎ ﺧﻴﺮ‪.‬‬
‫ﻣﺴﺎﺋﻠﯽ ﻧﻈﻴﺮ ﺯﻣﺎﻧﺒﻨﺪﯼ ﺑﺮﻧﺎﻣﻪﻫﺎ‪ ،‬ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﻣﻴﻨﻴﻤﻢ‪ ،‬ﺍﺩﻏﺎﻡ ﺩﻭﺩﻭﻳﻲ ﻭ ﺑﻬﻴﻨﻪ ﻓﺎﻳﻠﻬﺎ‪ ،‬ﺍﻧﺘﺨﺎﺏ ﻓﻌﺎﻟﻴﺘﻬﺎ ﻭ ‪ ...‬ﺭﺍ ﻣﻴﺘـﻮﺍﻥ‬
‫ﺗﻮﺳﻂ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ ﺣﻞ ﻧﻤﻮﺩ‪ .‬ﻣﺪﻝ ﮐﻠﯽ ﺭﻭﺵ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺎ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪function‬‬ ‫)‪Greedy(A,n‬‬
‫∅
‪solution‬‬
‫‪for i
1 to n do‬‬
‫)‪x
select (A‬‬
‫‪if feasible(x,solution) then‬‬
‫)‪solution
union (solution,x‬‬
‫‪endif‬‬
‫‪repeat‬‬
‫‪return solution‬‬
‫‪end .‬‬

‫‪Knapsack‬‬
‫(‬ ‫)‬

‫ﻪ‬ ‫ﻪ‬
‫‪١‬‬ ‫‪٣‬‬

‫ﯼ‬ ‫ﺮ‬ ‫ﺴ‬ ‫ﮐ‬ ‫ﺎ‬ ‫ﻳ‬ ‫ﻩ‬ ‫ﺩ‬ ‫ﺎ‬ ‫ﺳ‬ ‫ﺘ‬ ‫ﺸ‬ ‫ﻟ‬ ‫ﻮ‬ ‫ﻛ‬ ‫ﻟ‬ ‫ﺄ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻲ‬ ‫ﭘ‬

‫ﺩﺭ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﺗﻌﺪﺍﺩ ‪ n‬ﮐﻴﺴﻪ ﺍﺯ ﺍﺟﻨﺎﺱ ﻣﺨﺘﻠﻒ ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﯼ ﺩﺍﺩﻩ ﺷـﺪﻩ ﺍﺳـﺖ‪ .‬ﻫـﺮ ﮐﻴﺴـﻪ‬
‫ﺩﺍﺭﺍﯼ ﻭﺯﻥ ﻭ ﺳﻮﺩ ﻣﺸﺨﺼﯽ ﺍﺳﺖ‪ .‬ﺷﺨﺼﯽ ﺑﺎ ﻳﮏ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﻗﺼﺪ ﺍﻧﺘﺨـﺎﺏ ﺍﻳـﻦ ﺍﺟﻨـﺎﺱ ﺭﺍ ﺩﺍﺭﺩ‪ .‬ﻫـﺪﻑ‪ ،‬ﺍﻧﺘﺨـﺎﺏ‬
‫ﺍﺟﻨﺎﺱ ﻭ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ﺁﻧﻬﺎ ﺩﺭ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﺍﺳﺖ ﮐﻪ ﺳﻮﺩ ﺣﺎﺻﻠﻪ ﺑﻴﺸﻴﻨﻪ ﮔﺮﺩﺩ‪.‬‬
‫ﻭﺭﻭﺩﻱ‪:‬‬
‫‪ :n‬ﺗﻌﺪﺍﺩ ﮐﻴﺴﻪ ﻫﺎ‬
‫‪ :Pi‬ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺍﻧﺘﺨﺎﺏ ﻛﻞ ﮐﻴﺴﻪ ‪ i‬ﺍﹸﻡ‬
‫‪ :Wi‬ﻭﺯﻥ ﻛﻞ ﮐﻴﺴﻪ ‪ i‬ﺍﹸﻡ‬
‫‪ :M‬ﮔﻨﺠﺎﻳﺶ ﻛﻮﻟﻪ ﭘﺸﺘﯽ‬
‫‪n‬‬
‫ﻫﺪﻑ‪ :‬ﺑﻴﺸﻴﻨﻪ ﮐﺮﺩﻥ ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺍﻧﺘﺨﺎﺏ ﺍﺟﻨﺎﺱ ﻳﻌﻨﯽ ‪Max ∑ xi . pi‬‬
‫‪i =1‬‬

‫ﺷﺮﺍﻳﻂ ﻣﺴﺌﻠﻪ‪:‬‬
‫ﻭﺯﻥ ﻫﻤﻪ ﮐﻴﺴﻪﻫﺎ ﺭﻭﻱ ﻫﻢ ﺍﺯ ﻭﺯﻥ ﻛﻮﻟﻪﭘﺸﺘﻲ ﺑﻴﺸﺘﺮ ﺍﺳﺖ ﺯﻳﺮﺍ ﺍﮔﺮ ﻛﻤﺘﺮ ﺑﺎﺷـﺪ ﻳﻌﻨـﻲ ﻣـﻲﺗـﻮﺍﻧﻴﻢ ﻫﻤـﻪ ﺭﺍ ﺑـﺮﺩﺍﺭﻳﻢ ﻭ‬
‫ﺍﻧﺘﺨﺎﺑﻲ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﻫﻤﭽﻨﻴﻦ ﻣﺠﻤﻮﻉ ﻭﺯﻥ ﺍﺟﺴﺎﻣﻲ ﻛﻪ ﺍﻧﺘﺨﺎﺏ ﻛﺮﺩﻳﻢ ﺍﺯ ﻭﺯﻥ ﻛﻞ ﻛﻮﻟﻪﭘﺸﺘﻲ ﻧﺒﺎﻳﺪ ﺑﻴﺸﺘﺮ ﺷﻮﺩ‪.‬‬
‫‪n‬‬

‫‪∑w‬‬ ‫‪i >M‬‬

‫‪i =1‬‬ ‫‪-١‬‬
‫‪n‬‬

‫‪∑x w‬‬ ‫‪i‬‬ ‫‪i ≤M‬‬

‫‪i =1‬‬ ‫‪-٢‬‬

‫ﺧﺮﻭﺟﻲ‪ :‬ﻛﺴﺮﻱ ﺍﺯ ﮐﻴﺴﻪ ‪ i‬ﺍﹸﻡ ﻛﻪ ﺍﻧﺘﺨﺎﺏ ﻣﻲﺷﻮﺩ ﺩﺍﺧﻞ ﻋﻨﺼﺮ ‪ i‬ﺍﻡ ﺁﺭﺍﻳﻪ ﻗﺮﺍﺭ ﻣﻲﮔﻴﺮﺩ‪.‬‬
‫‪٢١‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫‪ = Xi‬ﮐﺴﺮﯼ ﺍﺯ ﮐﻴﺴﻪ ‪ i‬ﺍﻡ ﮐﻪ ﺍﻧﺘﺨﺎﺏ ﻣﻴﺸﻮﺩ‪(i=1,…,n) (0 ≤ Xi ≤ 1) .‬‬

‫ﺭﺍﻩ ﺣﻞ‪ :‬ﺗﻮﺳﻂ ﻣﺜﺎﻟﻬﺎﯼ ﻧﻘﻀﯽ ﻣﻴﺘﻮﺍﻥ ﻧﺸﺎﻥ ﺩﺍﺩ ﮐﻪ ﺍﻧﺘﺨﺎﺏ ﮐﻴﺴﻪ ﻫﺎ ﺑﺼﻮﺭﺕ ﺻﻌﻮﺩﯼ ﻭﺯﻥ ﻭ ﻳﺎ ﻧﺰﻭﻟـﯽ ﺳـﻮﺩ ﻣﻤﮑـﻦ‬
‫ﺍﺳﺖ ﻣﻨﺠﺮ ﺑﻪ ﺟﻮﺍﺏ ﺑﻬﻴﻨﻪ ﻧﮕﺮﺩﺩ! ﻭ ﻟﺬﺍ ﺭﺍﻩ ﺣﻞ ﺑﻬﻴﻨﻪ ﺑﻪ ﮔﻮﻧﻪ ﺍﯼ ﺍﺳﺖ ﮐﻪ ﺑﺎﻳﺪ ﮐﻴﺴﻪ ﻫﺎ ﺭﺍ ﺑﺼﻮﺭﺕ ﻧﺰﻭﻟـﯽ ﺳـﻮﺩ ﺑـﺮ‬
‫ﻭﺯﻧﺸﺎﻥ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩ‪.‬‬
‫ﺭﺍﻩﺣﻞ ﺑﻬﻴﻨﻪ ﺍﻳﻦ ﻣﻲﺑﺎﺷﺪ ﻛﻪ ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﻫﺮﻛﻴﻠﻮ ﺍﺯ ﺍﺟﺴﺎﻡ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩﻩ ﻭ ﺍﺯ ﺑـﺎ ﺍﺭﺯﺵﺗـﺮﻳﻦ ﺟﺴـﻢ ﺷـﺮﻭﻉ ﺑـﻪ‬
‫ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ ﻣﺎﺩﺍﻣﻲ ﻛﻪ ﻛﻮﻟﻪﭘﺸﺘﻲ ﻓﻀﺎ ﺑﺮﺍﻱ ﺟﺴﻢ ﺟﺪﻳﺪ ﺩﺍﺭﺩ‪ ،‬ﺩﺭ ﻏﻴﺮﺍﻳﻦ ﺻﻮﺭﺕ ﻛﺴـﺮﻱ ﺍﺯ ﺁﻥ ﺟﺴـﻢ ﺭﺍ ﺍﻧﺘﺨـﺎﺏ‬
‫ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫‪P1‬‬ ‫‪P‬‬ ‫‪P‬‬
‫‪≥ 2 ≥ ....... ≥ n‬‬
‫‪W1 W 2‬‬ ‫‪Wn‬‬
‫ﻣﺮﺗﺐ ﻣﻴﮑﻨﻴﻢ ﻭ ﺳﭙﺲ ﺑﻪ ﺗﺮﺗﻴﺐ ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﻴﻢ‪.‬‬ ‫ﺑﻪ ﺑﻴﺎﻥ ﺩﻳﮕﺮ ﺍﺑﺘﺪﺍ ﺍﺟﺴﺎﻡ ﺭﺍ ﺑﺼﻮﺭﺕ‬
‫ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Greedy- knapsack‬ﻭﺯﻥ ﺍﺟﺴﺎﻡ ﻣﺮﺗﺐ ﺷﺪﻩ ﺑﺮﺍﺳﺎﺱ ﺑﻴﺸﺘﺮﻳﻦ ﺳﻮﺩ ﻫﺮ ﻛﻴﻠﻮﯼ ﺁﻧﻬﺎ ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫‪ xi ) . 0 ≤ x i‬ﺩﺭﺍﻳﻪ ‪ i‬ﺍﻡ ﺁﺭﺍﻳﻪ ‪ X‬ﻣﻴﺒﺎﺷﺪ(‪ .‬ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﻮﺭﺩ ﻧﻈﺮ ﺩﺭ ﺯﻳﺮ ﺑﻴﺎﻥ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬ ‫‪≤1‬‬
‫ﺩﺭ ﻛﻮﻟﻪﭘﺸﺘﻲ ﺳﺎﺩﻩ‬

‫) ‪Procedure Greedy- knapsack ( W, n, M, X‬‬

‫‪cu
M‬‬
‫‪X
0‬‬
‫‪for i
1 to n do‬‬
‫‪if w(i) > cu then‬‬ ‫ﺍﮔﺮ ﺷﺮﻁ ﻣﻘﺎﺑﻞ ﺑﺮﻗﺮﺍﺭ ﻧﺒﺎﺷﺪ ﺟﺴﻢ ‪ i‬ﺍﹸﻡ ﺍﻧﺘﺨﺎﺏ ﻣﻲﺷﻮﺩ‬
‫)‪(feasibility‬‬ ‫‪Exit‬‬
‫‪endif‬‬
‫‪x(i)
1‬‬
‫)‪cu
cu- w(i‬‬
‫‪repeat‬‬
‫)‪x(i)
cu/w(i‬‬
‫‪end‬‬

‫ﺍﮔﺮ ﺷﺮﻁ ﺑﺮﻗﺮﺍﺭ ﺷﻮﺩ‪ ،‬ﻛﺴﺮﻱ ﺍﺯ ﺟﺴﻢ ‪ i‬ﺍﹸﻡ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻲﻛﻨﻴﻢ ﺗﺎ ﺑﻴﺸﺘﺮﻳﻦ ﺳﻮﺩ ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻭ ﻧﻴﺰ ﮐﻮﻟـﻪ ﮐـﺎﻣﻼﹰ ﭘـﺮ‬
‫ﺷﻮﺩ‪.‬‬
 ‫‪٢٢‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫(‬ ‫)‬

‫ﻪ‬ ‫ﺍ‬ ‫ﻪ‬ ‫ﺍ‬ ‫ﻪ‬

‫ﻏ‬ ‫‪٢‬‬ ‫‪٣‬‬

‫ﺐ‬ ‫ﺗ‬ ‫ﺮ‬ ‫ﻣ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﻫ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﺁ‬ ‫ﺎ‬ ‫ﻳ‬ ‫ﺎ‬ ‫ﻬ‬ ‫ﻳ‬ ‫ﺎ‬ ‫ﻓ‬ ‫ﻬ‬ ‫ﺑ‬ ‫ﻭ‬ ‫ﻳ‬ ‫ﻭ‬ ‫ﺩ‬ ‫ﻭ‬ ‫ﺩ‬ ‫ﻡ‬ ‫ﺎ‬ ‫ﺩ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻠ‬ ‫ﻨ‬ ‫ﻴ‬ ‫ﻲ‬ ‫ﻠ‬ ‫ﺌ‬

‫ﻳﺎﺩﺁﻭﺭﯼ‪ :‬ﻣﻴﺪﺍﻧﻴﻢ ﮐﻪ ﺑﺮﺍﯼ ﺍﺩﻏﺎﻡ ﺩﻭ ﺁﺭﺍﻳﻪ ﻳﺎ ﻓﺎﻳﻞ ﻣﺮﺗﺐ ﮐﻪ ﻫﺮ ﮐﺪﺍﻡ ﺑﻪ ﺗﺮﺗﻴﺐ ﺩﺍﺭﺍﯼ ‪ m1‬ﻭ ‪ m2‬ﺭﮐﻮﺭﺩﻳﺎ ﻋﻨﺼﺮ ﺑﺎﺷﻨﺪ‬
‫ﻧﻴﺎﺯ ﺑﻪ ﺯﻣﺎﻥ )‪ O(m1+m2‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﺣﺎﻝ ﺍﮔﺮ ﻫﺰﻳﻨﻪ ﺍﺩﻏﺎﻡ ﺍﻳﻦ ﺩﻭ ﺁﺭﺍﻳﻪ ﺭﺍ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ m1+m2‬ﺩﺭ ﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ‪ .‬ﺑﺎ ﻓـﺮﺽ‬
‫ﺩﺍﺷﺘﻦ ‪ n‬ﻓﺂﻳﻞ ﻣﺮﺗﺐ‪ ،‬ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﺭﻭﺷﯽ ﺟﻬﺖ ﺍﺩﻏﺎﻡ ﺩﻭﺩﻭﻳﻲ ﻭ ﺑﻬﻴﻨﻪ )ﮐﻤﺘـﺮﻳﻦ ﻫﺰﻳﻨـﻪ( ﺍﻳـﻦ ‪ n‬ﻓﺎﻳـﻞ ﻣﻴﺒﺎﺷـﺪ‪.‬‬
‫ﻣﻴﺪﺍﻧﻴﻢ ﮐﻪ ‪ n‬ﻓﺎﻳﻞ ﺭﺍ ﺑﻪ ﻃﺮﻕ ﻣﺨﺘﻠﻔﯽ ﻣﻴﺘﻮﺍﻥ ﺍﺩﻏﺎﻡ ﮐﺮﺩ ﮐﻪ ﻫﺮ ﻃﺮﻳﻖ ﺍﺩﻏﺎﻡ ﺩﺍﺭﺍﯼ ﺩﺭﺧﺖ ﺍﺩﻏﺎﻡ ﻣﺨﺼـﻮﺹ ﺑـﻪ ﺧـﻮﺩ‬
‫ﺍﺳﺖ‪ .‬ﺍﻟﮕﻮﺭﻳﺘﻤﻲ ﺑﺮﺍﻱ ﺳﺎﺧﺖ ﺑﻬﺘﺮﻳﻦ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﺍﺩﻏﺎﻡ ﻛﻪ ﺩﺍﺭﺍﻱ ﻛﻤﺘـﺮﻳﻦ ﻣﻘﺎﻳﺴـﻪ ﺟﻬـﺖ ﺭﺳـﻴﺪﻥ ﺍﺯ ﺑﺮﮔﻬـﺎﻱ‬
‫ﺩﺭﺧﺖ ﺑﻪ ﺭﻳﺸﻪ ﺁﻥ ﻣﻲﺑﺎﺷﺪ ﻣﻮﺭﺩ ﻧﻈﺮ ﺍﺳﺖ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺍﮔﺮ ﺳﻪ ﻓﺎﻳﻞ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ﻫﺎﯼ ‪ ۲۰ ،۱۰‬ﻭ ‪ ۳۰‬ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﺑﻪ ‪ ۳‬ﻃﺮﻳﻖ ﻣﻴﺘﻮﺍﻥ ﺁﻧﻬﺎ ﺭﺍ ﺍﺩﻏﺎﻡ ﮐـﺮﺩ ﮐـﻪ ﮐﻤﺘـﺮﻳﻦ ﻫﺰﻳﻨـﻪ‬
‫ﺍﺩﻏﺎﻡ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ ۹۰‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﺩﺭ ﺯﻳﺮ ﻫﺮ ﺳﻪ ﺩﺭﺧﺖ ﺍﺩﻏﺎﻡ ﺭﺍ ﻣﻴﺒﻴﻨﻴﻢ‪:‬‬

‫‪٠‬‬ ‫‪٠‬‬ ‫‪٠‬‬

‫‪١٠‬‬ ‫‪٠‬‬ ‫‪٩٠‬‬ ‫‪٢٠‬‬ ‫‪٣٠‬‬

‫‪٢٠‬‬ ‫‪٣٠‬‬ ‫‪١٠‬‬ ‫‪١٠‬‬ ‫‪٢٠‬‬ ‫‪٣٠‬‬

‫‪٣٠‬‬
‫‪٢‬‬

‫‪٢‬‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪٢‬‬

‫‪+‬‬

‫‪٢‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬

‫‪+‬‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٢‬‬ ‫‪٠‬‬

‫‪+‬‬

‫‪٢‬‬ ‫‪٢‬‬ ‫‪٢‬‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪٠‬‬

‫‪+‬‬ ‫‪+‬‬

‫‪٢‬‬ ‫‪٢‬‬ ‫‪٢‬‬

‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪١‬‬ ‫‪٠‬‬

‫‪+‬‬ ‫‪+‬‬

‫‪٢‬‬ ‫‪٢‬‬ ‫‪٢‬‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪٩‬‬

‫‪+‬‬ ‫‪+‬‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪٠‬‬ ‫‪١‬‬ ‫‪٠‬‬ ‫‪٠‬‬

‫‪+‬‬ ‫‪+‬‬

‫×‬ ‫×‬

‫=‬

‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪١‬‬ ‫‪٠‬‬ ‫‪١‬‬ ‫‪١‬‬ ‫‪٠‬‬

‫‪+‬‬ ‫‪+‬‬

‫×‬ ‫×‬

‫=‬

‫‪١‬‬ ‫‪٠‬‬ ‫‪٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬ ‫‪٠‬‬

‫‪+‬‬ ‫‪+‬‬

‫×‬ ‫×‬

‫=‬

‫ﺳﻮﺍﻝ‪ :‬ﺗﻌﺪﺍﺩ ﻃﺮﻕ ﺍﺩﻏﺎﻡ ‪ n‬ﻓﺎﻳﻞ ﺑﻪ ﺻﻮﺭﺕ ﺩﻭﺩﻭﻳﻲ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﮐﻨﻴﺪ‪:‬‬

‫‪A2=1‬‬
‫‪n ‬‬ ‫‪ n  n − 1 n − 2 ‬‬ ‫‪2‬‬
‫‪A n =   ∗ A n −1 =  ‬‬ ‫‪‬‬ ‫= ‪ ......  ‬‬
‫‪2 ‬‬ ‫‪ 2  2  2‬‬ ‫‪‬‬ ‫‪2‬‬
‫!‪n ! ( n − 1) ! ( n − 2 ) ! ..........2! 3! 2‬‬ ‫!)‪n ! ( n − 1‬‬
‫=‬ ‫=‬
‫! ‪2! ( n − 2 ) ! 2! ( n − 3) ! 2! ( n − 4 ) ! .......2! 2! 1! 2! n‬‬ ‫‪2n −1‬‬

‫ﻟﺬﺍ ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﻫﻤﻪ ﺩﺭﺧﺘﻬﺎﯼ ﺍﺩﻏﺎﻡ ﺭﺍ ﺗﻮﻟﻴﺪ ﮐﺮﺩﻩ ﻭ ﮐﻢ ﻫﺰﻳﻨﻪ ﺗﺮﻳﻦ ﺁﻧﻬﺎ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﻢ ﻫﺰﻳﻨﻪ ﺑﺴﻴﺎﺭ ﺯﻳﺎﺩﯼ ﺭﺍ ﺑﺎﻳـﺪ‬
‫ﭘﺮﺩﺍﺧﺖ ﮐﺮﺩ!‪ .‬ﻟﺬﺍ ﻧﻴﺎﺯ ﺑﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﯽ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠﻪﺍﯼ ﺑﻬﺘﺮﻳﻦ ﺩﺭﺧﺖ ﺍﺩﻏﺎﻡ ﺭﺍ ﺗﻮﻟﻴﺪ ﮐﻨﺪ‪.‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺳﺎﺧﺖ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﺑﺎ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ‪:‬‬
‫‪dist (v i ) = level (v i ) − 1‬‬
‫ﺗﻌﺮﻳﻒ‪ :‬ﻓﺎﺻﻠﻪ ﺍﺯ ﺭﻳﺸﻪ‬
‫ﺗﻌﺮﻳﻒ‪ :‬ﻣﻘﺪﺍﺭ ﻫﺰﻳﻨﻪﺍﻱ ﻛﻪ ﺑﺎﻳﺪ ﺻـﺮﻑ ﮐـﺮﺩ ﺗـﺎ ‪ n‬ﻓﺎﻳـﻞ ﺑﺼـﻮﺭﺕ ﺩﻭﺩﻭﻳـﻲ ﺍﺩﻏـﺎﻡ ﺷـﻮﻧﺪ ‪(WEPL=Weighted‬‬
‫)‪.External Path Length‬‬
‫‪n‬‬
‫= ‪W ep1‬‬ ‫‪∑dist (v‬‬
‫‪i =1‬‬
‫)‬
‫‪i ∗ cos t v i‬‬ ‫) (‬
 ‫‪٢٣‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﺗﻮﺿﻴﺢ ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﺑﺮﺍﻱ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻥ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﺑـﺎ ﻛﻤﺘـﺮﻳﻦ ﻫﺰﻳﻨـﻪ ﻳـﻚ ﻧـﻮﺩ ﺟﺪﻳـﺪ ﻣﻴﺴـﺎﺯﻳﻢ ﻭ ﺳـﭙﺲ ﻛـﻢ‬
‫ﺍﺭﺯﺵﺗﺮﻳﻦ ﻧﻮﺩ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩﻩ ﻭ ﺑﻪ ﻋﻨﻮﺍﻥ ﻓﺮﺯﻧﺪ ﭼـﭗ )‪ (left child‬ﮔـﺮﻩ ﺟﺪﻳـﺪ ﺩﺭﺝ ﻣﻴﮑﻨـﻴﻢ ﻭ ﺁﻥ ﺭﺍ ﺍﺯ ﻟﻴﺴـﺖ‬
‫ﺣﺬﻑ ﻣﻲﻛﻨﻴﻢ ﺳﭙﺲ ﺩﻭﺑﺎﺭﻩ ﻫﻤﻴﻦ ﻛﺎﺭ ﺭﺍ ﺑﺮﺍﻱ ﻓﺮﺯﻧﺪ ﺳﻤﺖ ﺭﺍﺳﺖ)‪ (rightchild‬ﺍﻧﺠﺎﻡ ﻣﻲﺩﻫﻴﻢ‪ .‬ﺳﭙﺲ ﮔـﺮﻩ ﺟﺪﻳـﺪ‬
‫ﺭﺍ ﺑﻪ ﻟﻴﺴﺖ ﺍﺿﺎﻓﻪ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺗﺎ ﻣﺎﺩﺍﻣﻲ ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻲﺩﻫﻴﻢ ﻛﻪ ﻫﻤﺔ ﻧﻮﺩﻫﺎﻱ ﻟﻴﺴﺖ )ﺑﻪ ﺟﺰ ﺁﺧﺮﯼ( ﺍﺯ ﻟﻴﺴﺖ ﺣﺬﻑ‬
‫ﺷﻮﻧﺪ‪ .‬ﮐﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﺍ ﺩﺭ ﺯﻳﺮ ﻣﯽﺑﻴﻨﻴﻢ‪:‬‬

‫)‪Function construct_tree(L,n‬‬
‫‪For i
1 to n-1 do‬‬
‫ﺭﻭﻳﻪ)‪ :least(L‬ﺩﺭ ﻟﻴﺴﺖ ﮐﻤﺘـﺮﻳﻦ ﻣﻘـﺪﺍﺭ ﺭﺍ ﭘﻴـﺪﺍ ﻛـﺮﺩﻩ ﺁﻥ ﺭﺍ ﺣـﺬﻑ ﻛـﺮﺩﻩ ﻭ‬
‫)‪Get node(T‬‬
‫)‪Lchild(T) least(L‬‬ ‫ﺁﺩﺭﺳﺶ ﺭﺍ ﺑﺮﻣﻲﮔﺮﺩﺍﻧﺪ‪.‬‬
‫)‪Rchild(T)  least(L‬‬
‫))‪Cost(T)  cost(Lchild(T))+cost(Rchild(T‬‬
‫)‪Insert(L,T‬‬
‫‪Repeat‬‬
‫)‪Return least(L‬‬
‫‪end .‬‬
‫‪ :Select‬ﻫﺮ ﺑﺎﺭ ﺩﻭ ‪ min‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﺪ‪.‬‬
‫‪ :Feasibility‬ﻧﺪﺍﺭﺩ‬
‫‪ :Union‬ﺑﻌﺪ ﺍﺯ ﭘﻴﻮﻧﺪ ﺑﻪ ﮔﺮﻩ ﺟﺪﻳﺪ ﺑﻪ ﻟﻴﺴﺖ ﺍﻭﻟﻴﻪ ﺍﺿﺎﻓﻪ ﻣﻲﻛﻨﺪ‪.‬‬

‫ﺷﮑﻞ ﺯﻳﺮ ﺭﻭﻧﺪ ﺳﺎﺧﺘﻪ ﺷﺪﻥ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﺍﺩﻏﺎﻡ ﺑﻬﻴﻨﻪ ﺭﺍ ﺑﺮ ﺭﻭﯼ ﺩﺍﺩﻩ ﻫﺎﯼ ﻭﺭﻭﺩﯼ ‪ ۷ ،۵ ،۳ ،۲‬ﻭ ‪ ۱۰‬ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‪.‬‬

‫‬
‫‪١‬‬

‫‪١‬‬ ‫‪٠‬‬

‫‪٧‬‬

‫‪١‬‬

‫‪٢‬‬
‫‬ ‫‬ ‫‪٧‬‬

‫‪٧‬‬

‫‪١‬‬ ‫‪٠‬‬

‫‪٣‬‬

‫‪٧‬‬

‫‪٧‬‬

‫‪١‬‬ ‫‪٧‬‬

‫‪١‬‬ ‫‪٠‬‬

‫‪١‬‬ ‫‪٠‬‬

‫‬ ‫‬

‫‪٢‬‬

‫‪٢‬‬

‫‪٣‬‬

‫‪٣‬‬

‫‪٢‬‬

‫‪٧‬‬ ‫‪٣‬‬
‫‪٢٤‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﮓ‬

‫‪Huffman‬‬
‫‪٣‬‬ ‫‪٣‬‬

‫ﻳ‬ ‫ﻛ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻨ‬ ‫ﺪ‬

‫ﻳﮑﯽ ﺍﺯ ﮐﺎﺭﺑﺮﺩﻫﺎﯼ ﻣﺴﺌﻠﻪ ﺍﺩﻏﺎﻡ ﺩﻭﺩﻭﻳﻲ ﻓﺎﻳﻠﻬﺎ ﺩﺭ ﮐﺪﻳﻨﮓ ﻫﺎﻓﻤﻦ ﺍﺳﺖ ﮐﻪ ﺟﻬﺖ ﻓﺸﺮﺩﻩ ﺳﺎﺯﯼ ﻓﺎﻳﻠﻬﺎ ﻳـﺎ ﺍﺭﺳـﺎﻝ ﮐـﻢ‬
‫ﺣﺠﻤﺘﺮ ﺍﻃﻼﻋﺎﺕ ﺑﺮ ﺭﻭﯼ ﺧﻄﻮﻁ ﺷﺒﮑﻪ ﻣﻮﺭﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻗﺮﺍﺭ ﻣﻴﮕﻴﺮﺩ‪ .‬ﺩﺭ ﺍﺑﺘﺪﺍ ﻳﻚ ﺟﺪﻭﻝ ﺩﺭﻧﻈـﺮ ﻣـﻲﮔﻴـﺮﻳﻢ ﺩﺭ ﺳـﺘﻮﻥ‬
‫ﺍﺑﺘﺪﺍﻳﻲ ﻣﻘﺎﺩﻳﺮ )ﺩﺍﺩﻩﻫﺎ( ﺭﺍ ﻭﺍﺭﺩ ﻣﻲﻛﻨﻴﻢ ﺩﺭ ﺳﺘﻮﻥ ﺩﻭﻡ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺩﺍﺩﻩﻫـﺎ ﺭﺍ ﻣﺤﺎﺳـﺒﻪ ﻛـﺮﺩﻩ ﻭ ﺑﺮﺍﺳـﺎﺱ ﺁﻥ ﺩﺭﺧـﺖ‬
‫ﺩﻭﺩﻭﻳﻲ ﺭﺍ ﻃﺒﻖ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Constract-tree‬ﻣﻲﺳﺎﺯﻳﻢ ﺳﭙﺲ ﻳﺎﻝﻫﺎﻱ ﭼﭗ ﺭﺍ ﺻﻔﺮ ﻭ ﻳﺎﻝﻫﺎﻱ ﺭﺍﺳﺖ ﺭﺍ ﻳﻚ ﺩﺭ ﻧﻈـﺮ‬
‫ﻣﻲﮔﻴﺮﻳﻢ ﺩﺭ ﺳﺘﻮﻥ ﺁﺧﺮ ﺟﺪﻭﻝ ﻛﺪﻫﺎﻱ ﺟﺪﻳﺪ ﺭﺍ ﮐﻪ ﺑﺮﭼﺴﺐ ﻳﺎﻟﻬﺎﯼ ﺩﺭﺧﺖ ﺣﺎﺻﻠﻪ ﺍﺯ ﺭﻳﺸـﻪ ﺗـﺎ ﻫـﺮ ﺑـﺮﮒ ﺍﺳـﺖ ﺭﺍ‬
‫ﺩﺭﺝ ﻣﻲﻛﻨﻴﻢ‪ .‬ﺍﻳﻦ ﺑﺮﭼﺴﺒﻬﺎ ﺭﺍ ﻛﺪﻳﻨﮓ ﻫﺎﻓﻤﻦ ﻣﻴﻨﺎﻣﻴﻢ‪ .‬ﺑﺮﭼﺴﺒﻬﺎﯼ ﺟﺪﻳﺪ ﮐﺪﻫﺎﯼ ﺟﺎﻳﮕﺰﻳﻦ ﮐﺪﻫﺎﯼ ﻗﺒﻠﯽ ﺧﻮﺍﻫﻨـﺪ ﺷـﺪ‬
‫ﮐﻪ ﺩﺭ ﻓﺸﺮﺩﻩ ﺳﺎﺯﯼ ﻓﺎﻳﻠﻬﺎ ﺣﺠﻢ ﮐﻤﺘﺮﯼ ﺭﺍ ﺑﻪ ﺧﻮﺩ ﺍﺧﺘﺼﺎﺹ ﻣﻴﺪﻫﺪ‪ .‬ﺟﻬﺖ ﺑﺎﺯﮔﺮﺩﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﻪ ﺣﺎﻟـﺖ ﺍﻭﻟﻴـﻪ ﻧﻴـﺰ ﺍﺯ‬
‫ﺑﺮﻋﮑﺲ ﻫﻤﻴﻦ ﺭﻭﺵ ﻣﻴﺘﻮﺍﻥ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ)ﺑﺪﻳﻬﯽ ﺍﺳﺖ ﮐﻪ ﺑﺎﻳﺪ ﺍﻃﻼﻋﺎﺗﯽ ﺩﺭ ﻓﺎﻳﻞ ﻓﺸﺮﺩﻩ ﺷﺪﻩ ﻗﺮﺍﺭ ﺩﺍﺩ ﮐﻪ ﺍﺯ ﺭﻭﯼ ﺁﻧﻬﺎ‬
‫ﺑﺘﻮﺍﻥ ﻣﺠﺪﺩﺍﹰ ﺩﺭﺧﺖ ﮐﺪﻳﻨﮓ ﺭﺍ ﺳﺎﺧﺖ(!‪.‬‬

‫ﻓﺎﻳﻞ ﺍﻭﻟﻴﻪ‬
‫‪١٠٠‬‬ ‫‪١١٠‬‬ ‫‪٠١١‬‬ ‫‪٠١١‬‬ ‫‪١٠٠‬‬ ‫‪٠١٠‬‬ ‫‪١٠٠‬‬

‫ﺩﺍﺩﻩ‬ ‫ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ‬ ‫ﻛﺪﻳﻨﮓ ﻫﺎﻓﻤﻦ‬

‫‪٠٠٠‬‬ ‫‪٠‬‬ ‫‪----‬‬
‫‪٠٠١‬‬ ‫‪٠‬‬ ‫‪----‬‬
‫‪٠١٠‬‬ ‫‪١‬‬ ‫‪١٠٠‬‬
‫‪٠١١‬‬ ‫‪٢‬‬ ‫‪١١‬‬
‫‪١٠٠‬‬ ‫‪٣‬‬ ‫‪٠‬‬
‫‪١٠١‬‬ ‫‪٠‬‬ ‫‪----‬‬
‫‪١١٠‬‬ ‫‪١‬‬ ‫‪١٠١‬‬
‫‪١١١‬‬ ‫‪٠‬‬ ‫‪----‬‬

‫ﻓﺎﻳﻞ ﻧﻬﺎﻳﻲ‬
‫‪۰‬‬ ‫‪۱۰۱‬‬ ‫‪۱۱‬‬ ‫‪۱۱‬‬ ‫‪۰‬‬ ‫‪۱۰۰‬‬ ‫‪۰‬‬
‫‪٢٥‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫‪7‬‬
‫‪1‬‬

‫‪0‬‬
‫‪0‬‬ ‫‪4‬‬

‫‪2‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬

‫‪3‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬

‫‪0‬‬ ‫‪100‬‬ ‫‪101‬‬ ‫‪11‬‬

‫‪۴‬‬
‫‪۳‬‬

‫ﻣ‬ ‫ﻱ‬ ‫ﺎ‬ ‫ﺷ‬ ‫ﻮ‬ ‫ﺭ‬ ‫ﺩ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻢ‬ ‫ﻤ‬

‫ﻴ‬ ‫ﻨ‬ ‫ﻴ‬ ‫ﭘ‬ ‫ﺖ‬ ‫ﺧ‬

‫ﻣﺴﺌﻠﻪ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺑﺮ ﺭﻭﯼ ﻳﮏ ﮔﺮﺍﻑ ﻫﻤﺒﻨﺪ ﻭﺯﻧﺪﺍﺭ ﺍﺯ ﺟﻤﻠﻪ ﻣﺴﺎﺋﻞ ﭘـﺮ ﮐـﺎﺭﺑﺮﺩﯼ ﺩﺭ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﮔﺮﺍﻑ ﻣﺤﺴﻮﺏ ﻣﻴﺸﻮﺩ‪ .‬ﮔﺮﺍﻑ ﻫﻤﺒﻨﺪ ﻭﺯﻧﺪﺍﺭ )‪ G(V,E‬ﻣﻔﺮﻭﺽ ﺍﺳﺖ‪ ،‬ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﺯﻳﺮﮔﺮﺍﻓـﻲ ﺍﺯ‬
‫‪ G‬ﺍﺳﺖ ﮐﻪ ﺩﺍﺭﺍﯼ ﺧﻮﺍﺹ ﺯﻳﺮ ﺑﺎﺷﺪ‪:‬‬
‫‪ -۷‬ﺷﺎﻣﻞ ﻫﻤﻪ ﮔﺮﻩ ﻫﺎﯼ ‪ V‬ﺑﺎﺷﺪ‬
‫‪ -۸‬ﻫﻤﺒﻨﺪ ﻭ ﺑﺪﻭﻥ ﺣﻠﻘﻪ ﺑﺎﺷﺪ‬
‫‪ -۹‬ﺩﺭ ﺑﻴﻦ ﮐﻠﻴﻪ ﺯﻳﺮﮔﺮﺍﻓﻬﺎﻳﻲ ﮐﻪ ﺷﺮﻁ ‪ ۱‬ﻭ ‪ ۲‬ﺭﺍ ﺩﺍﺭﻧﺪ ﺩﺍﺭﺍﯼ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺑﺎﺷﺪ‬
‫ﺑﺮﺍﯼ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﻣﺘﻌﺪﺩﯼ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﺍﺯ ﺑﻴﻦ ﺁﻧﻬﺎ ﺑﻪ ﺑﻴﺎﻥ ﺩﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮐﻪ ﺭﻭﺵ ﻃﺮﺍﺣﯽ ﺁﻧﻬﺎ ﺣﺮﻳﺼـﺎﻧﻪ‬
‫ﺍﺳﺖ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺍﮔﺮ ﮔﺮﺍﻑ ﻭﺭﻭﺩﯼ ﻫﻤﺒﻨﺪ ﻧﺒﺎﺷﺪ‪ ،‬ﺩﺍﺭﺍﯼ ﺩﺭﺧﺖ ﭘﻮﺷﺎ ﻧﻴﺴﺖ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﻳﮏ ﮔﺮﺍﻑ ﺑﺎ ‪ n‬ﺭﺍﺱ ﺩﻗﻴﻘﺎﹰ ﺩﺍﺭﺍﯼ ‪ n-1‬ﻳﺎﻝ ﻣﻴﺒﺎﺷﺪ‪ .‬ﺍﮔﺮ ﻳﮏ ﻳﺎﻝ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﮐﻨﻴﻢ ﺷـﺮﻁ ﺑـﺪﻭﻥ‬
‫ﺣﻠﻘﻪ ﺑﻮﺩﻥ ﺁﻥ ﻧﻘﺾ ﻣﻴﺸﻮﺩ ﻭ ﺍﮔﺮ ﻳﮏ ﻳﺎﻝ ﺍﺯ ﺁﻥ ﺣﺬﻑ ﮐﻨﻴﻢ ﺷﺮﻁ ﻫﻤﺒﻨـﺪ ﺑـﻮﺩﻥ ﺁﻥ ﻧﻘـﺾ ﺧﻮﺍﻫـﺪ ﺷـﺪ‪ .‬ﺩﺭ ﻧﺘﻴﺠـﻪ‬
‫ﻣﻴﺘﻮﺍﻥ ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﻳﮏ ﮔﺮﺍﻑ ﺑﺎ ‪ n‬ﺭﺍﺱ ﺭﺍ ﺑﻪ ﺍﻳﻦ ﺻﻮﺭﺕ ﺗﻌﺮﻳﻒ ﮐﺮﺩ‪ :‬ﺯﻳﺮ ﺩﺭﺧﺘﯽ ﺍﺯ ﮔﺮﺍﻑ ﮐـﻪ ﺩﺍﺭﺍﯼ ‪ n-1‬ﻳـﺎﻝ‬
‫ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪kruskal‬‬
‫(‬ ‫)‬ ‫ﻝ‬

‫‪١‬‬ ‫‪٤‬‬ ‫‪٣‬‬

‫ﺎ‬ ‫ﺷ‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺍ‬ ‫ﺭ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻳﮏ ﻳﺎﻝ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺍﺯ ﮔﺮﺍﻑ ﻭﺭﻭﺩﯼ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﻭ ﺍﺯ ﮔﺮﺍﻑ ﺣﺬﻑ ﺷـﺪﻩ ﻭ ﺩﺭ‬
‫ﺻﻮﺭﺗﻴﮑﻪ ﺍﺿﺎﻓﻪ ﮐﺮﺩﻥ ﺁﻥ ﺑﻪ ﺩﺭﺧﺖ ﻣﻮﺟﺐ ﺍﻳﺠﺎﺩ ﺣﻠﻘﻪ ﻧﺸﻮﺩ ﺁﻥ ﺭﺍ ﺑﻪ ﺩﺭﺧﺖ ﻣﻮﺭﺩ ﻧﻈـﺮ )ﮐـﻪ ﺩﺭ ﺍﺑﺘـﺪﺍﯼ ﺍﻟﮕـﻮﺭﻳﺘﻢ‬
٢٦ (Greedy) ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‬

‫ ﺷـﺒﻪ ﮐـﺪ‬.‫ ﻳﺎﻝ ﺑﻪ ﺩﺭﺧﺖ ﺍﺿﺎﻓﻪ ﻧﺸﺪﻩ ﺍﺳـﺖ ﺍﺩﺍﻣـﻪ ﻣﻴﺎﺑـﺪ‬n-1 ‫ ﺍﻳﻦ ﻋﻤﻞ ﺗﺎ ﺯﻣﺎﻧﻴﮑﻪ ﺗﻌﺪﺍﺩ‬.‫ﺧﺎﻟﯽ ﺍﺳﺖ( ﺍﺿﺎﻓﻪ ﻣﻴﮑﻨﻴﻢ‬
.‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺩﺭ ﺷﮑﻞ ﺯﻳﺮ ﻣﻴﺒﻴﻨﻴﻢ‬

Procedure kruskal
T  ∅ 11
While ( |T| < n-1 ) and ( |E| ≠ 0 ) do
Select edge e from E with minimum cost a d 3
7
Delete e from E 10
If e does not create a cycle in T then 2 9 f
c
add e to T 5 4
endif b 8
repeat e
if |T| < n-1 then write ('no spanning Tree ') endif 6
end.
:‫ﻣﺮﺍﺣﻞ ﺳﺎﺧﺖ ﺩﺭﺧﺖ‬

a d 3
a

2 f
2

b b

a d 3 a d 3

2 f f
c 2 c
4 5 4
b b
e e

a d 3

2 f
c
5 4
8
b
e
‫‪٢٧‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﺑﺮﺍﺑﺮ ﺑﺎ )‪ O(e. log n‬ﻣﻴﺒﺎﺷﺪ!‪.‬‬

‫‪Prim‬‬
‫‪٢‬‬ ‫‪٤‬‬ ‫‪٣‬‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﭘﺮﻳﻢ‪ ،‬ﻣﺎﻧﻨﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍﺷﺎﻝ ﺩﺭ ﻫﺮ ﺯﻣﺎﻥ ﻳﮏ ﻟﺒﻪ ﺍﺯ ﺩﺭﺧﺖ ﭘﻮﺷﺎﻱ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺭﺍ ﻣﻲﺳﺎﺯﺩ‪ .‬ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫ﭘﺮﻳﻢ ﺍﺯ ﻳﮏ ﺭﺍﺱ ﺩﻟﺨﻮﺍﻩ ﺷﺮﻭﻉ ﮐﺮﺩﻩ ﻭ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﻳﺎﻝ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﮐﻪ ﻳﮏ ﺭﺍﺱ ﻣﺠﺎﻭﺭ ﺁﻥ ﺩﺭ ﺩﺭﺧﺖ ﺑﻮﺩﻩ ﻭ‬
‫ﺭﺍﺱ ﺩﻳﮕﺮﺵ ﺩﺭ ﺩﺭﺧﺖ ﻧﺒﺎﺷﺪ ﺭﺍ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ‪ ،‬ﻣﺠﻤﻮﻋﻪ ﻟﺒﻪﻫﺎﻱ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﻳـﮏ ﺩﺭﺧـﺖ ﺭﺍ‬
‫ﺗﺸﮑﻴﻞ ﻣﻲﺩﻫﻨﺪ ﻭ ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﺩﺭﺧﺖ ﮔﺴﺘﺮﺵ ﻣﻴﺎﺑﺪ‪ .‬ﺩﺭﻣﻘﺎﺑﻞ‪ ،‬ﻣﺠﻤﻮﻋﻪ ﻟﺒﻪﻫﺎﻱ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﺩﺭ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺭﺍﺷـﺎﻝ‬
‫ﺩﺭ ﻫﺮﻣﺮﺣﻠﻪ ﻳﮏ ﺟﻨﮕﻞ ﺭﺍ ﺗﺸﮑﻴﻞ ﻣﻲﺩﻫﻨﺪ‪ .‬ﺷﺒﻪ ﮐﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺩﺭ ﺷﮑﻞ ﺯﻳﺮ ﻣﻴﺒﻴﻨﻴﻢ‪.‬‬
‫)‪Procdure prim(v,E,T‬‬
‫∅‪T‬‬
‫}‪Tv{1‬‬
‫‪While |T| < n-1 do‬‬
‫‪Select e= (u,v) with minimum cost from E such that u∈Tv and v∉Tv‬‬
‫‪if there is no any such edge then‬‬ ‫! رأس ل 
رد در دا‪ "#& Tv‬و رأس د‪."#$ %‬‬
‫‪exit‬‬ ‫ا‪# +‬ط در )
ر( &‪,‬ار (‪
#‬د آ‪1 2‬اف ا)‪  (/‬ه‪."#$ "4$-‬‬
‫‪endif‬‬
‫‪add e to T‬‬
‫‪add v to Tv‬‬
‫‪repeat‬‬
‫‪if |T|<n-1 then write ('no spanning tree') endif‬‬
‫‪end.‬‬
‫ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﺑﺮﺍﺑﺮ ﺑﺎ )‪ O(e. log n‬ﻣﻴﺒﺎﺷﺪ!‪.‬‬
‫ﺩﺭﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫‪Select :‬‬ ‫ﻫﺰﻳﻨﻪ ﻛﻤﺘﺮ ﺑﺎ ﺷﺮﺍﻳﻂ ﺧﺎﺹ‬
‫ﺑﻪ ﻋﻠﺖ ﻧﺤﻮﻩ ﺍﻧﺘﺨﺎﺏ ﻳﺎﻝﻫﺎ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ‪feasibility :‬‬

‫‪Prim Kruskal‬‬
‫ﻘ‬

‫‪٣‬‬ ‫‪٤‬‬ ‫‪٣‬‬

‫ﻪ‬

‫ﺎ‬

‫ﻭ‬ ‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬ ‫ﺴ‬ ‫ﻳ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫ﺩﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ prim‬ﻭ ‪ kruskal‬ﺩﺭﺻﻮﺭﺗﻲ ﺩﻭ ﺩﺭﺧﺖ ﻣﺘﻔﺎﻭﺕ ﺗﻮﻟﻴﺪ ﻣﻴﮑﻨﻨﺪ ﻛﻪ ﭼﻨﺪﻳﻦ ﻳﺎﻝ ﺑﺎ ﻫﺰﻳﻨـﻪﻫـﺎﻱ ﻣﺴـﺎﻭﻱ‬
‫ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻭﻟﯽ ﻫﻤﻴﺸﻪ ﻫﺰﻳﻨﻪ ﺩﺭﺧﺘﻬﺎﯼ ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﺑﺮﺍﺑﺮ ﻭ ﮐﻤﻴﻨﻪ ﺍﺳﺖ‪ .‬ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Prim‬ﺩﺭ ﺍﺑﺘﺪﺍ ﻳﻚ ﮔﺮﻩ ﺑﻮﺩﻩ ﻭ‬
‫ﮐﻢ ﮐﻢ ﺩﺭ ﺣﻴﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮔﺴﺘﺮﺵ ﻣﻴﺎﺑﺪ ﺗﺎ ﺑﻪ ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﮐﻤﻴﻨﻪ ﺗﺒﺪﻳﻞ ﺷﻮﺩ ﺩﺭﺣﺎﻟﻴﻜﻪ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ kruskal‬ﭼﻨﺪ‬
‫ﺩﺭﺧﺖ )ﺟﻨﮕﻞ( ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺩﺭ ﺍﻧﺘﻬﺎﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭﺧﺘﻬﺎﯼ ﺟﻨﮕﻞ ﺑﻪ ﻫﻢ ﭘﻴﻮﻧﺪ ﺧﻮﺭﺩﻩ ﺗﺎ ﺗﺒﺪﻳﻞ ﺑﻪ ﺩﺭﺧـﺖ ﭘﻮﺷـﺎﯼ‬
‫ﮐﻤﻴﻨﻪ ﺷﻮﻧﺪ‪.‬‬

‫‪Kn‬‬
‫‪٤‬‬ ‫‪٤‬‬ ‫‪٣‬‬

‫ﯼ‬ ‫ﺎ‬ ‫ﺷ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﻬ‬

‫ﭘ‬ ‫ﺘ‬ ‫ﺧ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﻮ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﺩ‬ ‫ﺍ‬ ‫ﺪ‬ ‫ﻌ‬

‫ﺩﺭ ﺍﻳﻦ ﺑﺨﺶ ﺑﻪ ﺑﻴﺎﻥ ﻗﻀﻴﻪ ﻣﻬﻤﯽ ﺩﺭ ﻣﻮﺭﺩ ﺗﻌﺪﺍﺩ ﺩﺭﺧﺘﻬﺎﯼ ﭘﻮﺷﺎ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺩﺭﺧﺘﻬﺎﯼ ﭘﻮﺷﺎﯼ ‪ K4‬ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‪:‬‬
‫‪٢٨‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﻗﻀﻴﻪ‪ :‬ﺛﺎﺑﺖ ﻛﻨﻴﺪ ﺗﻌﺪﺍﺩ ﺩﺭﺧﺘﻬﺎﻱ ﭘﻮﺷﺎﻱ ‪) kn‬ﮔﺮﺍﻑ ﮐﺎﻣﻞ ﺑﺎ ‪ n‬ﺭﺍﺱ( ﺑﺮﺍﺑﺮ ‪ nn-2‬ﺍﺳﺖ‪.‬‬
‫ﺍﺛﺒﺎﺕ‪ :‬ﺍﺯ ﺭﻭﺵ ﺯﻳﺮ ﺑﺮﺍﻱ ﺍﺛﺒﺎﺕ ﻗﻀﻴﻪ ﺑﺎﻻ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲﻛﻨﻴﻢ‪:‬‬
‫ﺍﺑﺘﺪﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﻴﻢ ﮐﻪ ﻫﺮ ﺩﺭﺧﺖ ﭘﻮﺷﺎ ﺑﺎ‪ n‬ﺭﺃﺱ ﺩﺭ ﺗﻨﺎﻇﺮ ﻳﻚ ﺑﻪ ﻳﻚ ﻳﺎ ﻳﻚ ﺭﺷﺘﻪ ‪ n-2‬ﺣﺮﻓﻲ ﺭﻭﻱ ‪ n‬ﺣﺮﻑ ﺍﺳﺖ ﻭ‬
‫ﺳﭙﺲ ﭼﻮﻥ ﺗﻌﺪﺍﺩ ﺭﺷﺘﻪ ﻫﺎﯼ ‪ n-2‬ﺣﺮﻓﯽ ﺭﻭﯼ ‪ n‬ﺣﺮﻑ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ nn-2‬ﺍﺳﺖ ﻗﻀﻴﻪ ﺛﺎﺑﺖ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﺑﺎﻳﺪ ﺍﺯ ﻫﺮﺩﺭﺧﺖ ﭘﻮﺷﺎ ﺑﻪ ﻳﻚ ﺭﺷﺘﻪ ﺑﺮﺳﻴﻢ ﻭ ﺑﺮﻋﻜﺲ‪ .‬ﺑﺎ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺯﻳﺮ ﻣﻴﺘﻮﺍﻥ ﺑﺮﺍﯼ ﻫﺮ ﺩﺭﺧﺖ ﭘﻮﺷﺎ ﻳـﮏ ﺭﺷـﺘﻪ ‪n-2‬‬
‫ﺣﺮﻓﯽ ﻳﮑﺘﺎ ﺗﻮﻟﻴﺪ ﮐﺮﺩ‪.‬‬
‫‪ -۱‬ﺑﻪ ﺍﺯﺍﯼ ‪ i‬ﺍﺯ ‪ ۱‬ﺗﺎ ‪ n-2‬ﻣﺮﺣﻠﻪ ‪ ۲‬ﺭﺍ ﺗﮑﺮﺍﺭ ﮐﻨﻴﺪ‪:‬‬
‫‪ -۲‬ﮐﻮﭼﮑﺘﺮﻳﻦ )ﺍﺯ ﻟﺤﺎﻅ ﺗﺮﺗﻴﺐ ﺍﻟﻔﺒﺎﻳﻲ ﻳﺎ ﻋﺪﺩﻱ( ﺑﺮﮒ )ﺭﺍﺱ ﺑﺎ ﺩﺭﺟﻪ ‪ (۱‬ﺭﺍ ﺍﺯ ﺩﺭﺧـﺖ ﺣـﺬﻑ ﮐـﺮﺩﻩ ﻭ ﺭﺍﺱ‬
‫ﻣﺠﺎﻭﺭ ﻳﺎﻝ ﻣﺮﺑﻮﻁ ﺑﻪ ﺁﻥ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ‪ i‬ﺍﻣﻴﻦ ﻋﻨﺼﺮ ﺭﺷﺘﻪ ﻣﺤﺴﻮﺏ ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫‪١‬‬ ‫‪٢‬‬ ‫‪٣‬‬ ‫‪٤‬‬
‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪d‬‬

‫‪a‬‬
‫‪b‬‬
‫
‬ ‫‬
‫‪c‬‬
‫‬

‫‪d‬‬
‫‬

‫‪f‬‬ ‫‪e‬‬
‫‪٢٩‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﻣﺮﺣﻠﻪ ﺍﻭﻝ‪:‬‬
‫‪c‬‬

‫‪b‬‬

‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬

‫ﻣﺮﺣﻠﻪ ﺩﻭﻡ‪:‬‬
‫‪c‬‬ ‫‪c‬‬ ‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬

‫ﻣﺮﺣﻠﻪ ﺳﻮﻡ‪:‬‬
‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬

‫ﻣﺮﺣﻠﻪ ﭼﻬﺎﺭﻡ‪:‬‬
‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪d‬‬

‫‪d‬‬

‫‪f‬‬
‫ﻋﻜﺲ ﺭﻭﺵ ﺑﺎﻻ )ﺭﺳﻴﺪﻥ ﺍﺯ ﺭﺷﺘﻪ ﺑﻪ ﺩﺭﺧﺖ(‪:‬‬
‫ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﻣﺜﺎﻝ ﺑﺎﻻ ﻃﻮﻝ ﺭﺷﺘﻪ ﻣﻮﺭﺩﻧﻈﺮ ﺭﺍ ﺑﺎ ﺩﻭ ﺟﻤﻊ ﻛﺮﺩﻩ ﺗﻌﺪﺍﺩ ﺭﺋﻮﺱ ﺑﺪﺳﺖ ﻣﻲﺁﻳﺪ ﺳﭙﺲ ﺩﺭ ﻣﺮﺣﻠﻪ ﺑﻌﺪ ﺟـﺪﻭﻟﻲ‬
‫ﺍﺯ ﻛﻠﻴﻪ ﺣﺮﻭﻑ ﺗﻬﻴﻪ ﻣﻲﻛﻨﻴﻢ ﺣﺎﻝ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﻫﺮ ﺣـﺮﻑ ﺩﺭ ﺭﺷـﺘﻪ ﺭﺍ ﺑـﻪ ﺍﺿـﺎﻓﻪ ﻳـﻚ ﻣـﻲﻛﻨـﻴﻢ ﻭ ﺩﺭ ﺟـﺪﻭﻝ ﻗـﺮﺍﺭ‬
‫‪٣٠‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﻣﻲﺩﻫﻴﻢ)ﻗﺎﺑﻞ ﺫﮐﺮ ﺍﺳﺖ ﮐﻪ ﺩﺭﺟﻪ ﻫﺮ ﮔﺮﻩ ﺩﺭ ﺩﺭﺧﺖ ﭘﻮﺷﺎ ﺑﺮﺍﺑﺮ ﺑﺎ ﻳﮑﯽ ﺑﻴﺸﺘﺮ ﺍﺯ ﺗﻌﺪﺍﺩ ﺩﻓﻌﺎﺕ ﻇﻬـﻮﺭ ﮔـﺮﻩ ﺩﺭ ﺭﺷـﺘﻪ‬
‫ﺍﺳﺖ(‪.‬‬
‫‪ -۱‬ﺑﻪ ﺍﺯﺍﯼ ‪ i‬ﺍﺯ ‪ ۱‬ﺗﺎ ‪ n-2‬ﻣﺮﺣﻠﻪ ‪ ۲‬ﻭ ‪۳‬ﺭﺍ ﺗﮑﺮﺍﺭ ﮐﻨﻴﺪ‪:‬‬
‫‪ -۲‬ﮐﻮﭼﮑﺘﺮﻳﻦ ﺭﺍﺱ ﺑﺎ ﺩﺭﺟﻪ ‪ ۱‬ﺩﺭ ﺟﺪﻭﻝ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩﻩ ﻭ ﻳﺎﻟﯽ ﺑﻴﻦ ﺁﻥ ﺭﺍﺱ ﻭ ﺣﺮﻑ ‪ i‬ﺍﻡ ﺭﺷﺘﻪ ﺑﺮﻗﺮﺍﺭ ﮐﻨﻴﺪ‪.‬‬
‫‪ -۳‬ﺍﺯ ﺩﺭﺟﻪ ﺩﻭ ﺭﺍﺳﯽ ﮐﻪ ﺩﺭ ﻣﺮﺣﻠﻪ ‪ ۲‬ﺑﻴﻦ ﺁﻧﻬﺎ ﻳﺎﻟﯽ ﺑﺮﻗﺮﺍﺭ ﺷﺪ ﻳﮏ ﻭﺍﺣﺪ ﮐﻢ ﮐﻨﻴﺪ‬
‫‪ -۴‬ﻳﺎﻟﯽ ﺑﻴﻦ ﺩﻭ ﺭﺍﺱ ﺑﺎﻗﻴﻤﺎﻧﺪﻩ ﺑﺮﻗﺮﺍﺭ ﮐﻨﻴﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪f‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪1‬‬

‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪d‬‬

‫ﺷﺮﻭﻉ ﮐﺎﺭ‪:‬‬
‫‪a‬‬ ‫‪b‬‬

‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬

‫ﻣﺮﺣﻠﻪ ﺍﻭﻝ‪:‬‬
‫ﺑﺎ ﺣﺮﻛﺖ ﺍﺯ ﺳﺮﺭﺷﺘﻪ )ﻛﻪ‪ c‬ﻣﻲﺑﺎﺷﺪ( ﻭ ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﺟﺪﻭﻝ ﻛﻮﭼﻜﺘﺮﻳﻦ ﺑﺮﮒ ﺭﺍ )‪ (a‬ﺍﻧﺘﺨﺎﺏ ﻣﻲﻛﻨـﻴﻢ ﺣـﺎﻝ ﺍﺯ ﺩﺭﺟـﻪ ‪c‬‬
‫ﻳﻜﻲ ﻛﻢ ﻛﺮﺩﻩ ﻭ ﻫﻤﻴﻨﻄﻮﺭ ﺍﺯ ﺩﺭﺟﻪ ﺑﺮﮒ ﻛﻪ)‪ (a‬ﻣﻲﺑﺎﺷﺪ ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﺑﺮﺍﻱ ﻣﺮﺍﺣﻞ ﺑﻌﺪ ﻧﻴﺰ ﺍﻧﺠﺎﻡ ﻣﻲﺩﻫﻴﻢ‪.‬‬
‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪f‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪2‬‬

‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪D‬‬

٣١ (Greedy) ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‬

a b

f e
:‫ﻣﺮﺣﻠﻪ ﺩﻭﻡ‬

a b c d e f
1 1 3 3 1 1
0 0 2
1

c c d d

a b

f e

:‫ﻣﺮﺣﻠﻪ ﺳﻮﻡ‬
a b c d e f
1 1 3 3 1 1
0 0 2 2
1
0
‫‪٣٢‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪d‬‬

‫‪a‬‬ ‫‪b‬‬

‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬

‫ﻣﺮﺣﻠﻪ ﭼﻬﺎﺭﻡ‪:‬‬
‫ﺩﺭ ﺍﻳﻦ ﻣﺮﺣﻠﻪ ﺩﻭ ﻧﻮﺩ ﺍﻧﺘﻬﺎﻳﻲ ﺭﺍ ﺑﻪ ﻳﻜﺪﻳﮕﺮ ﻭﺻﻞ ﻣﻲﻛﻨﻴﻢ‪.‬‬

‫‪a‬‬ ‫‪b‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪e‬‬ ‫‪f‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪3‬‬ ‫‪3‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬

‫‪c‬‬ ‫‪c‬‬ ‫‪d‬‬ ‫‪d‬‬

‫‪a‬‬ ‫‪b‬‬

‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬
‫ﻣﺮﺣﻠﻪ ﺁﺧﺮ‪:‬‬

‫‪a‬‬ ‫‪b‬‬

‫‪c‬‬

‫‪d‬‬

‫‪f‬‬ ‫‪e‬‬
‫‪٣٣‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﺍ‬

‫‪٣‬‬

‫‪٥‬‬

‫ﻣ‬ ‫ﻫ‬ ‫ﻱ‬ ‫ﺎ‬ ‫ﻫ‬ ‫ﺮ‬ ‫ﺴ‬ ‫ﻣ‬ ‫ﻦ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﻫ‬ ‫ﺎ‬ ‫ﺗ‬ ‫ﻮ‬ ‫ﻛ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻢ‬

‫ﺪ‬ ‫ﺒ‬ ‫ﻴ‬

‫ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﺑﺮﺭﺳﯽ ﻣﺴﺌﻠﻪ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎﯼ ﻫﻢ ﻣﺒـﺪﺍ )‪ (Single Source Shortest Paths‬ﻳـﺎ ‪SSSP‬‬
‫ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪ .‬ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﻣﺘﻌﺪﺩﯼ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﻃﻮﻝ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺑﻴﻦ ﺩﻭ ﮔﺮﻩ ﺩﺭ ﮔﺮﺍﻑ ﻭﺯﻧﺪﺍﺭ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﺩﺭ‬
‫ﺍﻳﻦ ﻣﻴﺎﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Dijkstra‬ﺑﻪ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ ﻃﺮﺍﺣﯽ ﺷﺪﻩ ﺍﺳﺖ ﻟﺬﺍ ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﺑﻴﺎﻥ ﺁﻥ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪ .‬ﺩﺭ ﺍﻳـﻦ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﻃﻮﻝ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺍﺯ ﻳﻚ ﮔﺮﻩ ﻣﺒﺪﺍ ﻧﻈﻴـﺮ ‪ v‬ﺑـﻪ ﮔـﺮﻩﻫـﺎﻱ ﺩﻳﮕـﺮ ﻣـﻲﺑﺎﺷـﺪ‪ .‬ﺍﻟﮕـﻮﺭﻳﺘﻢ‬
‫ﺩﺍﻳﮑﺴﺘﺮﺍ ﺑﺮ ﺭﻭﯼ ﮔﺮﺍﻓﻬﺎﯼ ﻭﺯﻧﺪﺍﺭﯼ ﻗﺎﺑﻞ ﺍﺟﺮﺍﺳﺖ ﮐﻪ ﻫﺰﻳﻨﻪ ﻳﺎﻟﻬﺎ ﻧﺎﻣﻨﻔﯽ ﺑﺎﺷﺪ‪.‬‬

‫ﻓﺮﺿﻴﺎﺕ‪:‬‬
‫‪Dist[i]:‬‬ ‫ﻃﻮﻝ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺍﺯ ﺭﺍﺱ ‪ v‬ﺑﻪ ﺭﺍﺱ ‪i‬‬
‫‪n:‬‬ ‫ﺗﻌﺪﺍﺩ ﺭﺋﻮﺱ‬
‫‪V:‬‬ ‫ﻣﺒﺪﺃ‪:‬‬
‫‪cost:‬‬ ‫ﻣﺎﺗﺮﻳﺲ ﻫﺰﻳﻨﻪﻫﺎ‪:‬‬
‫‪p[i]:‬‬ ‫ﺭﺍﺳﯽ ﻗﺒﻞ ﺍﺯ ﺭﺍﺱ ‪ i‬ﺑﺮ ﺭﻭﺱ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ‬

‫ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﻣﺒﺪﺍ ﺑﻪ ﻫﺮ ﺭﺍﺱ ﮐﻢ ﮐﻢ ﻣﺤﺎﺳـﺒﻪ ﺷـﺪﻩ ﻭ ﺩﺭ ﻫـﺮ ﻣﺮﺣﻠـﻪ ﮐﻤﺘـﺮ ﻣﻴﺸـﻮﺩ ﺗـﺎ ﺩﺭ ﭘﺎﻳـﺎﻥ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ ﮐﻤﺘﺮﻳﻦ ﺣﺪ ﺧﻮﺩ ﺑﺮﺳﺪ‪ .‬ﺩﺭ ﺣﻴﻦ ﺍﺟﺮﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻫﺮ ﺭﺍﺳﯽ ﮐﻪ ﻓﺎﺻﻠﻪ ﻣﺒﺪﺍ ﺑـﻪ ﺁﻥ ﺑﻄـﻮﺭ ﮐﺎﻣـﻞ ﻣﺤﺎﺳـﺒﻪ‬
‫ﺷﺪﻩ ﺑﻮﺩ ﻭ ﻣﻘﺪﺍﺭ ﺁﻥ ﺑﻪ ﮐﻤﺘﺮﻳﻦ ﺣﺪ ﺧﻮﺩ ﺭﺳﻴﺪﻩ ﺑﺎﺷﺪ ﺑﺮﭼﺴﺐ ﺩﺍﺋﻤﯽ ﺷﺪﻥ )‪ (s[w]=1‬ﺧﻮﺍﻫـﺪ ﺧـﻮﺭﺩ‪ .‬ﺩﺭ ﺍﺑﺘـﺪﺍﯼ‬
‫ﮐﺎﺭ ﻫﻤﻪ ﺭﺋﻮﺱ ﺑﻪ ﻏﻴﺮ ﺍﺯ ﻣﺒﺪﺍ ﺩﺍﺭﺍﯼ ﺑﺮﭼﺴﺐ ﻣﻮﻗﺘﯽ ﻫﺴﺘﻨﺪ)‪.(s[w]=0‬‬

‫ﺗﻮﺿﻴﺢ‪ :‬ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ‪ ۲‬ﻓﺎﺯ ﻣﻴﺒﺎﺷﺪ)ﻣﺮﺣﻠﻪ ‪ ۲‬ﻭ ‪:(۳‬‬

‫‪ -۱‬ﻣﺮﺍﺣﻞ ‪ ۲‬ﻭ ‪ ۳‬ﺭﺍ ‪ n-2‬ﺑﺎﺭ ﺗﮑﺮﺍﺭ ﮐﻨﻴﺪ‪:‬‬
‫‪ -۲‬ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﺍﺯ ﻣﻴﺎﻥ ﺭﺋﻮﺳﯽ ﮐﻪ ﻫﻨﻮﺯ ﺑﺮﭼﺴﺐ ﺩﺍﺋﻤﯽ ﺷﺪﻥ ﻧﺨﻮﺭﺩﻩﺍﻧـﺪ ﺭﺍﺳـﯽ ﮐـﻪ ﺩﺍﺭﺍﯼ ﮐﻤﺘـﺮﻳﻦ ﻓﺎﺻـﻠﻪ‬
‫ﻧﺴﺒﺖ ﺑﻪ ﻣﺒﺪﺍ ﺍﺳﺖ )ﮐﻤﺘﺮﻳﻦ ‪ (Dist‬ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﻴﻢ ﻭ ﺁﻥ ﺭﺍ ﺑﺮﭼﺴﺐ ﺩﺍﺋﻤﯽ ﻣﻴﺰﻧﻴﻢ‪.‬‬
‫‪ -۳‬ﻣﻘﺪﺍﺭ ‪ Dist‬ﻣﺎﺑﻘﯽ ﺭﺋﻮﺳﯽ ﺭﺍ ﮐﻪ ﻫﻨﻮﺯ ﻣﻮﻗﺘﯽ ﻫﺴﺘﻨﺪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺭﺍﺱ ﺩﺍﺋﻤﯽ ﺷﺪﻩ ﺩﺭ ﻣﺮﺣﻠﻪ ‪ ۱‬ﺑﺮﻭﺯ ﻣﻴﮑﻨﻴﻢ‪.‬‬
٣٤ (Greedy) ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‬

:‫ﺷﺒﻪ ﮐﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺯﻳﺮ ﺁﻭﺭﺩﻩ ﺷﺪﻩ ﺍﺳﺖ‬

Procedure (G, n, v, cost, dist)

For i1 to n do
dist[i]  cost (v,i)
p[i]  v
s[i]  false
repeat
s[v]  True
for i1 to n-2 do
select vertex u such that dist (u)= min {dist(w) | s(w)= false}
s[u]  true
for all vertices w in which s(w) = false do
if dist (u) +cost (u,w) <dist (w) then
dist (w)  dist (u) + cost (u,w)
p[w]  u
end if (*)
repeat
repeat
end.

:‫ﻣﺜﺎﻝ‬
‫ ﺑـﺎ‬P ‫ ﻭ‬Dist ‫ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺒﺪﺍ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﻢ ﺁﻧﮕﺎﻩ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺗﻐﻴﻴﺮﺍﺗـﯽ ﺭﺍ ﺩﺭ ﺁﺭﺍﻳـﻪ‬۱ ‫ﺍﮔﺮ ﺩﺭ ﮔﺮﺍﻑ ﺯﻳﺮﺍ ﺭﺍﺱ ﺷﻤﺎﺭﻩ‬
.‫ ﻣﻴﺘﻮﺍﻥ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺭﺍ ﺭﺳﻢ ﮐﺮﺩ‬p ‫ ﻭ‬dist ‫ ﺑﺎﺗﻮﺟﻪ ﺑﻪ ﺳﺘﻮﻥ‬.‫ﺗﻮﺟﻪ ﺑﻪ ﺟﺪﺍﻭﻝ ﺯﻳﺮﺍ ﺑﻮﺟﻮﺩ ﺧﻮﺍﻫﺪ ﺁﻭﺭﺩ‬

12 2 6
9 5
2 12
3
1 3 5 6
2
7 1
4 15
٣٥ (Greedy) ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‬

:‫ﻣﺮﺣﻠﻪ ﺷﺮﻭﻉ‬
Vertex S Dist P
1 1 0 1
2 0 12 1
3 0 2 1

4 0 7 1
5 0 ∞ 1
6 0 ∞ 1

Vertex S Dist P
1 1 0 1
2 0 11 3
3 1 2 1

4 0 4 3
5 0 5 3
6 0 ∞ 1

Vertex S Dist P
1 1 0 1
2 0 11 3
3 1 2 1

4 1 4 3
5 0 5 3
6 0 21 4
‫‪٣٦‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫‪Vertex S‬‬ ‫‪Dist‬‬ ‫‪P‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪0‬‬ ‫‪10‬‬ ‫‪5‬‬
‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬

‫‪4‬‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪3‬‬

‫‪5‬‬ ‫‪1‬‬ ‫‪5‬‬ ‫‪3‬‬
‫‪6‬‬ ‫‪0‬‬ ‫‪17‬‬ ‫‪5‬‬

‫‪Vertex S‬‬ ‫‪Dist‬‬ ‫‪P‬‬

‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪2‬‬ ‫‪1‬‬ ‫‪10‬‬ ‫‪5‬‬
‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪1‬‬

‫‪4‬‬ ‫‪1‬‬ ‫‪4‬‬ ‫‪3‬‬

‫‪5‬‬ ‫‪1‬‬ ‫‪5‬‬ ‫‪3‬‬
‫‪6‬‬ ‫‪0‬‬ ‫‪16‬‬ ‫‪2‬‬

‫ﺩﺭ ﺳﻄﺮ‪ ٢‬ﺁﺭﺍﻳﻪ ‪ p‬ﺭﺃﺱ ‪ ۵‬ﻗﺮﺍﺭ ﺩﺍﺭﺩ‪ ،‬ﻭ ﺍﻳﻦ ﺑﺪﺍﻥ ﻣﻌﻨﻲ ﺍﺳﺖ ﻛﻪ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺑﺮﺍﻱ ﺭﻓﺘﻦ ﺑﻪ ﺭﺃﺱ‪ ٢‬ﺍﺯ ﻃﺮﻳﻖ ﺭﺃﺱ ‪،٥‬‬
‫ﻣﻲﺑﺎﺷﺪ ﺩﺭ ﻧﺘﻴﺠﻪ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺍﺯ ﺭﺍﺱ ‪ ۱‬ﺑﻪ ﺭﺍﺱ ‪ ۲‬ﺑﺼﻮﺭﺕ )‪ (1352‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﺍﺯ ﺭﻭﯼ ﺁﺭﺍﻳـﻪ ‪ p‬ﻣﻴﺘـﻮﺍﻥ‬
‫ﺩﺭﺧﺘﯽ ﺗﻮﻟﻴﺪ ﮐﺮﺩ ﮐﻪ ﺑﻪ ﻧﺎﻡ ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺑﻪ ﻣﺒﺪﺍ )ﺭﻳﺸﻪ( ‪ v‬ﻣﻌﺮﻭﻑ ﺍﺳﺖ )‪)(SPST‬ﺍﮔﺮ ﮔـﺮﺍﻑ‬
‫ﺍﻭﻟﻴﻪ ﻫﻤﺒﻨﺪ ﺑﺎﺷﺪ ﺩﺭﺧﺖ ﺣﺎﺻﻞ ﺍﺯ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺑﻪ ﺭﻳﺸـﻪ ‪ v‬ﻧﻴـﺰ ﭘﻮﺷـﺎ ﺍﺳـﺖ(‪ .‬ﺷـﮑﻞ ﺯﻳـﺮ ﺩﺭﺧـﺖ ﭘﻮﺷـﺎﯼ‬
‫ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺑﻪ ﻣﺒﺪﺍ ﺭﺍﺱ ‪ ۱‬ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‪.‬‬

‫‪2‬‬ ‫‪1‬‬
‫‪5‬‬ ‫‪6‬‬
‫‪2‬‬
‫‪1‬‬ ‫‪3‬‬ ‫‪5‬‬
‫‪3‬‬

‫‪2‬‬

‫‪4‬‬
‫ﺗﻄﺎﺑﻖ ﺑﺎ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‪:‬‬
‫‪Select:‬‬ ‫ﺍﻧﺘﺨﺎﺏ ﺭﺍﺱ ﻣﻮﻗﺘﯽ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ‪Dist‬‬
‫‪Feasibility:‬‬ ‫‪-------------‬‬
‫‪Union:‬‬ ‫ﺩﺭ ﺑﺮﻧﺎﻣﻪ ) *(‬
‫‪٣٧‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺑﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻫﺮ ﻳﮏ ﺍﺯ ﺭﺋﻮﺱ ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺒﺪﺍ ﻭ ﺍﺟﺮﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻴـﺎﻥ ﺷـﺪﻩ ﻣﻴﺘـﻮﺍﻥ ﺑـﻪ ‪ n‬ﺩﺭﺧـﺖ ﭘﻮﺷـﺎﯼ‬
‫ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺭﺳﻴﺪ ﮐﻪ ﻣﻤﮑﻦ ﺍﺳﺖ ﻫﻴﭻ ﮐﺪﺍﻡ ﺍﺯ ﺁﻧﻬﺎ ﺩﺭﺧﺖ ﭘﻮﺷﺎﯼ ﮐﻤﻴﻨﻪ ﻧﺒﺎﺷﺪ‪ .‬ﮔﺮﺍﻑ ﺯﻳﺮ ﻧﺸﺎﻥ ﺩﻫﻨـﺪﻩ ﺍﻳـﻦ‬
‫ﻣﻮﺿﻮﻉ ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪3‬‬

‫‪1‬‬ ‫‪5‬‬
‫‪7‬‬

‫‪7‬‬ ‫‪3‬‬

‫ﺗﺤﻠﻴﻞ ﺯﻣﺎﻧﯽ‪ :‬ﺑﺮﺍﺣﺘﯽ ﻣﻼﺣﻈﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﺼﻮﺭﺗﯽ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﮐﺮﺩ ﮐﻪ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺁﻥ )‪O(n2‬‬
‫ﮔﺮﺩﺩ!‪.‬‬

‫)‪(Activity Selection‬‬
‫ﻪ‬ ‫ﺍ‬

‫‪۶‬‬ ‫‪۳‬‬

‫ﺎ‬ ‫ﻬ‬ ‫ﺘ‬ ‫ﻟ‬ ‫ﺎ‬ ‫ﻌ‬ ‫ﻓ‬ ‫ﻬ‬ ‫ﺑ‬ ‫ﺏ‬ ‫ﺎ‬ ‫ﺨ‬ ‫ﺘ‬ ‫ﻧ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻴ‬ ‫ﻨ‬ ‫ﻴ‬

‫ﻣﺴﺌﻠﻪ ﺩﻳﮕﺮﯼ ﮐﻪ ﺑﺮﺍﯼ ﺁﻥ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺭﺍﺣﺘﯽ ﺍﻟﮕﻮﺭﻳﺘﻤﯽ ﺑﻪ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ ﺗﻮﻟﻴﺪ ﮐﺮﺩ‪ ،‬ﻣﺴﺌﻠﻪ ﺍﻧﺘﺨﺎﺏ ﻓﻌﺎﻟﻴﺘﻬﺎ ﻧـﺎﻡ ﺩﺍﺭﺩ‪.‬‬
‫ﻓﺮﺽ ﮐﻨﻴﺪ ‪ n‬ﺳﺨﻨﺮﺍﻥ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﮐﻪ ﻫﺮ ﮐﺪﺍﻡ ﺯﻣﺎﻥ ﺷﺮﻭﻉ ﻭ ﭘﺎﻳﺎﻥ ﺳﺨﻨﺮﺍﻧﯽ ﺧﻮﺩ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﯼ ﻣﺴـﺌﻠﻪ ﺍﻋـﻼﻡ‬
‫ﮐﺮﺩﻩﺍﻧﺪ‪ .‬ﻫﺪﻑ ﺍﻧﺘﺨﺎﺏ ﺑﻴﺸﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﺳﺨﻨﺮﺍﻥ ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﺍﺳﺖ ﮐﻪ ﻫﻴﭻ ﺩﻭ ﺳـﺨﻨﺮﺍﻧﯽ ﺑـﺎ ﻫـﻢ ﺍﺷـﺘﺮﺍﮎ ﺑـﺎﺯﻩ ﺯﻣـﺎﻧﯽ‬
‫ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺟﻬﺖ ﻋﺪﻡ ﺗﺪﺍﺧﻞ ﺩﺭ ﺯﻣﺎﻥ ﺷﺮﻭﻉ ﻳﺎ ﭘﺎﻳﺎﻥ ﻣﻴﺘﻮﺍﻥ ﺑﺪﻭﻥ ﮐﻢ ﺷﺪﻥ ﺍﺯ ﮐﻠﻴﺖ ﻣﺴـﺌﻠﻪ ﻓـﺮﺽ ﮐـﺮﺩ ﮐـﻪ ﭘﺎﻳـﺎﻥ ﺑـﺎﺯﻩ‬
‫ﺳﺨﻨﺮﺍﻧﻴﻬﺎ ﺑﺎﺯ ﻣﻴﺒﺎﺷﻨﺪ ﻳﻌﻨﯽ ﺑﺼﻮﺭﺕ )…[ ﻣﻴﺒﺎﺷﻨﺪ‪.‬‬

‫ﻭﺭﻭﺩﻱ‪:‬‬
‫‪ :Si‬ﺷﺮﻭﻉ ﻓﻌﺎﻟﻴﺖ ‪ i‬ﺍﹸﻡ‬
‫‪ :Fi‬ﭘﺎﻳﺎﻥ ﻓﻌﺎﻟﻴﺖ ‪ i‬ﺍﹸﻡ‬
‫‪ :n‬ﺗﻌﺪﺍﺩ ﻓﻌﺎﻟﻴﺘﻬﺎ‬
‫ﻫﺪﻑ‪ :‬ﺍﻧﺘﺨﺎﺏ ﺑﻴﺸﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﻓﻌﺎﻟﻴﺖ ﺑﻪ ﻗﺴﻤﻲ ﻛﻪ ﺍﺷﺘﺮﺍﻙ ﺑﺎﺯﻩ ﺯﻣﺎﻧﻲ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬
‫ﺗﻮﺿﻴﺢ ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫‪ -۱‬ﺩﺭﺍﺑﺘﺪﺍ ﻓﻌﺎﻟﻴﺘﻬﺎ ﺭﺍ ﺑﺮﺍﺳﺎﺱ ﺯﻣﺎﻥ ﭘﺎﻳﺎﻥ ﺁﻧﻬﺎ ﻣﺮﺗﺐ ﮐﺮﺩﻫﻮ ﺳـﭙﺲ ﺍﻭﻟـﻴﻦ ﻓﻌﺎﻟﻴـﺖ )ﺯﻭﺩﺗـﺮﻳﻦ ﺯﻣـﺎﻥ ﭘﺎﻳـﺎﻥ( ﺭﺍ‬
‫ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫‪ -۲‬ﺑﻪ ﺍﺯﺍﯼ ‪ i‬ﺍﺯ ‪ ۲‬ﺗﺎ ‪ n‬ﻣﺮﺣﻠﻪ ‪ ۳‬ﺭﺍ ﺗﮑﺮﺍﺭ ﻣﻴﮑﻨﻴﻢ‪:‬‬
‫‪ -۳‬ﺍﮔﺮ ﻓﻌﺎﻟﻴﺖ ‪ i‬ﺍﻡ ﺑﺎ ﺁﺧﺮﻳﻦ ﻓﻌﺎﻟﻴﺖ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﺗﺪﺍﺧﻞ ﺑﺎﺯﻩ ﺯﻣﺎﻧﯽ ﻧﺪﺍﺷﺖ ﺁﻥ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﻴﻢ‪.‬‬

‫ﺷﺒﻪ ﮐﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﺩﺭ ﺯﻳﺮ ﻣﻴﺒﻴﻨﻴﻢ)ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﻓﻌﺎﻟﻴﺘﻬﺎ ﺑﺮ ﺣﺴﺐ ﺻﻌﻮﺩﯼ ﺯﻣﺎﻥ ﭘﺎﻳﺎﻧﺸﺎﻥ ﻣﺮﺗﺐ ﺷﺪﻩﺍﻧﺪ(‪:‬‬
‫‪٣٨‬‬ ‫ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ )‪(Greedy‬‬

‫)‪Procedure Activity_selector (A, S, F, n‬‬

‫}‪A {1‬‬
‫‪j1‬‬
‫‪for i2 to n do‬‬
‫‪if Si ≥ Fj then‬‬
‫}‪A  A ∪ {i‬‬
‫‪j i‬‬
‫‪endif‬‬
‫‪repeat‬‬
‫‪end.‬‬

‫ﺷﮑﻞ ﺯﻳﺮ ﻧﻤﻮﻧﻪ ﺍﻱ ﺍﺯ ﻳﮏ ﻣﺜﺎﻝ ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‪.‬‬

‫√‬
‫√‬ ‫√‬ ‫√‬

‫ﺗﻄﺎﺑﻖ ﺑﺎ ﺭﻭﺵ ﺣﺮﻳﺼﺎﻧﻪ‪:‬‬

‫‪select :‬‬ ‫ﻓﻌﺎﻟﻴﺘﻲ ﻛﻪ ﺯﻭﺩﺗﺮﻳﻦ ﺯﻣﺎﻥ ﭘﺎﻳﺎﻥ ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‬
‫ﺑﺎ ﺁﺧﺮﻳﻦ ﻓﻌﺎﻟﻴﺖ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﺗﺪﺍﺧﻞ ﺯﻣﺎﻧﯽ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ ‪feasibility:‬‬
‫‪Union:‬‬ ‫ﺍﺿﺎﻓﻪ ﮐﺮﺩﻥ ﺁﻥ ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﻫﺎ‬
‫ﺗﺤﻠﻴﻞ ﺯﻣﺎﻧﯽ‪ :‬ﺑﻴﺸﺘﺮﻳﻦ ﺯﻣﺎﻥ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺮﺑﻮﻁ ﺑﻪ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺍﺑﺘﺪﺍﯼ ﮐﺎﺭ ﺍﺳﺖ ﻭ ﻟﺬﺍ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﻱ ﻣﺮﺗﺒﻪ ﺯﻣـﺎﻧﻲ‬
‫)‪ O(n log n‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫‪selection‬‬ ‫‪si‬‬ ‫‪fi‬‬
‫‬ ‫‪1‬‬ ‫‪4‬‬
‫‪-‬‬ ‫‪3‬‬ ‫‪5‬‬
‫‪-‬‬ ‫‪0‬‬ ‫‪6‬‬
‫‬ ‫‪5‬‬ ‫‪7‬‬
‫‪-‬‬ ‫‪3‬‬ ‫‪8‬‬
‫‪-‬‬ ‫‪5‬‬ ‫‪9‬‬
‫‪-‬‬ ‫‪6‬‬ ‫‪10‬‬
‫‬ ‫‪8‬‬ ‫‪11‬‬
‫‪-‬‬ ‫‪8‬‬ ‫‪11‬‬
‫‪-‬‬ ‫‪2‬‬ ‫‪13‬‬
‫‬ ‫‪12‬‬ ‫‪14‬‬
 ‫(‬ ‫)‬

‫‪۴‬‬

‫‪Divide & Conquer‬‬ ‫ﻞ‬ ‫ﺣ‬ ‫ﻭ‬ ‫ﻢ‬ ‫ﻴ‬ ‫ﺴ‬ ‫ﻘ‬ ‫ﺗ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬ ‫‪-‬‬

‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺍﺑﺘﺪﺍ ﺍﺯ ﻣﺴﺄﻟﻪ ﺍﺻﻠﻲ ﺷﺮﻭﻉ ﮐﺮﺩﻩ ﻭ ﺁﻥ ﺭﺍ ﺑﻪ ﻣﺴﺎﺋﻞ ﮐﻮﭼﮑﺘﺮ ﺗﻘﺴﻴﻢ ﻣـﻲﮐﻨـﻴﻢ‪ .‬ﺳـﭙﺲ ﻫـﺮ ﻳـﮏ ﺍﺯ ﺯﻳـﺮ‬
‫ﻣﺴﺎﺋﻞ ﺭﺍ ﺑﺼﻮﺭﺕ ﺑﺎﺯﮔﺸﺘﯽ ﺣﻞ ﮐﺮﺩﻩ ﻭ ﺟﻮﺍﺏ ﺣﻞ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺭﺍ ﺑﺎ ﻫﻢ ﺗﺮﮐﻴﺐ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺍﻳﻦ ﺭﻭﺵ ﻣﻨﻄﺒﻖ ﺑـﺮ ﺍﻟﮕـﻮﻱ‬
‫ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﻣﻲﺑﺎﺷﺪ)‪ ،(Top Down‬ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﻓﻀﺎﯼ ﺣﻞ ﻣﺴﺌﻠﻪ ﺍﺯ ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﺗﺎ ﺑﻪ ﮐـﻮﭼﮑﺘﺮﻳﻦ‬
‫ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﺑﺮﺳﻴﻢ ﻭ ﺳﭙﺲ ﺍﺯ ﮐﻮﭼﮑﺘﺮﻳﻦ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺣﻞ ﺷﺪﻩ ﻭ ﺑﺎ ﻫﻢ ﺗﺮﮐﻴﺐ ﻣﻴﺸﻮﻧﺪ‪ .‬ﻣﺸﮑﻞ ﺍﻳﻦ ﺭﻭﺵ ﺩﺭ ﺍﻳﻦ ﺍﺳﺖ‬
‫ﮐﻪ ﻣﻤﮑﻦ ﺍﺳﺖ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺗﮑﺮﺍﺭﯼ ﻣﺤﺎﺳﺒﻪ ﺷﻮﻧﺪ ﻭ ﻟﺬﺍ ﻣﻨﺠﺮ ﺑﻪ ﺑﺎﻻ ﺭﻓﺘﻦ ﺯﻣﺎﻥ ﺣﻞ ﻣﺴﺌﻠﻪ ﮔﺮﺩﺩ‪ .‬ﺩﺭ ﻫﻨﮕـﺎﻡ ﺗﻘﺴـﻴﻢ‪،‬‬
‫ﻣﺴﺄﻟﻪ ﺑﺰﺭﮔﺘﺮ ﺑﻪ ﻣﺴﺎﺋﻞ ﮐﻮﭼﮑﺘﺮ ﺷﮑﺴﺘﻪ ﻣﻲ ﺷﻮﺩ ﺍﻣﺎ ﻫﻤﻴﺸﻪ ﺍﻳﻨﻄﻮﺭ ﻧﻴﺴـﺖ‪ ،‬ﺑﺎﻳـﺪ ﺗﻌـﺪﺍﺩ ﺗﻘﺴـﻴﻤﺎﺕ ﺭﺍ ﺑـﻪ ﮔﻮﻧـﻪ ﺍﻱ‬
‫ﮔﺮﻓﺖ ﮐﻪ ﮐﺎﺭﺍﻳﻲ ﺑﻴﺸﺘﺮﻳﻦ ﻣﻘﺪﺍﺭ ﺑﺎﺷﺪ‪ ،‬ﻫﺮﭼﻪ ﺍﻧﺪﺍﺯﻩ ﻣﺴﺎﺋﻞ ﮐﻮﭼﮏ ﺑﻪ ﻫﻢ ﻧﺰﺩﻳﮑﺘﺮ ﺑﺎﺷﺪ ﻣﻌﻤﻮﻻﹰ ﮐﺎﺭﺁﻳﻲ ﺣﺎﺻﻞ ﺑﻴﺸﺘﺮ‬
‫ﺍﺳﺖ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺳﻌﻲ ﻣﻲﺷﻮﺩ ﺍﻧﺪﺍﺯﻩ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺗﻘﺮﻳﺒﺎﹰ ﺑﺎ ﻫﻢ ﻣﺴﺎﻭﻱ ﺑﺎﺷﻨﺪ‪ .‬ﺷﺒﻪ ﮐﺪ ﮐﻠﯽ ﺭﻭﻧـﺪ ﺣـﻞ ﻣﺴـﺎﺋﻞ ﺩﺭ ﺭﻭﺵ‬
‫ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﻣﻴﺒﺎﺷﺪ‪:‬‬
‫)‪Procdure D&C (p,q‬‬
‫‪if small (p,q) then‬‬
‫)‪return G(p,q‬‬
‫‪else‬‬
‫)‪m
divide (p,q‬‬
‫))‪return combine (D&C(p,m) , D&C(m+1,q‬‬
‫‪endif‬‬
‫‪end.‬‬
‫ﺑﺮﺍﯼ ﺍﺭﺍﺋﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﻳﺪ ﺟﺰﺋﻴﺎﺕ ﺗﻮﺍﺑﻊ ‪ divide ، G ، small‬ﻭ ‪ combine‬ﺭﺍ ﻣﺸﺨﺺ ﮐﺮﺩ‪Small .‬‬
‫ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﺩﺭ ﻣﻮﺭﺩ ﮐﻮﭼﮏ ﺑﻮﺩﻥ ﺍﻧﺪﺍﺯﻩ ﻣﺴﺌﻠﻪ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﺪ ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﺩﺭ ﺍﻳﻦ ﺗﺎﺑﻊ ﻣﺸﺨﺺ ﻣﻴﺸﻮﺩ ﮐﻪ ﺍﮔﺮ‬
‫ﺍﻧﺪﺍﺯﻩ ﻣﺴﺌﻠﻪ ﺑﻪ ﺣﺪ ﮐﺎﻓﯽ ﮐﻮﭼﮏ ﺍﺳﺖ ﮐﻪ ﺩﻳﮕﺮ ﻧﻴﺎﺯﯼ ﺑﻪ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺑﺎﺯﮔﺸﺘﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﺒﺎﺷﺪ ﻋﻤﻞ ﺗﻘﺴﻴﻢ ﻣﺴـﺌﻠﻪ ﺑـﻪ‬
‫ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﭘﺎﻳﺎﻥ ﻣﻴﺎﺑﺪ‪ .‬ﺗﺎﺑﻊ ‪ G‬ﻣﺴﺌﻠﻪ ﺑﺎ ﺍﻧﺪﺍﺯﻩ ﮐﻮﭼﮏ ﺭﺍ ﺣﻞ ﻣﻴﮑﻨﺪ‪ .‬ﺗﺎﺑﻊ ‪ divide‬ﻭﻇﻴﻔﻪ ﺗﻘﺴﻴﻢ ﻣﺴﺌﻠﻪ ﺑﻪ ﺯﻳﺮ ﻣﺴﺎﺋﻞ‬
‫ﮐﻮﭼﮑﺘﺮ ﺭﺍ ﺑﻪ ﻋﻬﺪﻩ ﺩﺍﺭﺩ ﻭ ﺗﺎﺑﻊ ‪ combine‬ﻫﻢ ﺗﺮﮐﻴﺐ ﺟﻮﺍﺏ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﺪ‪.‬‬

‫ﻪ‬ ‫ﺍ‬ ‫ﻪ‬ ‫ﻪ‬ ‫ﻪ‬ ‫‪۴‬‬

‫‪۱‬‬

‫ﻳ‬ ‫ﺭ‬ ‫ﺁ‬ ‫ﮏ‬ ‫ﻳ‬ ‫ﺸ‬ ‫ﺑ‬ ‫ﻭ‬ ‫ﮐ‬ ‫ﺮ‬ ‫ﺼ‬ ‫ﺳ‬ ‫ﺎ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬

‫ﻨ‬ ‫ﻴ‬ ‫ﻴ‬ ‫ﻨ‬ ‫ﻴ‬ ‫ﻨ‬ ‫ﻋ‬ ‫ﺒ‬ ‫ﺤ‬

‫ﺗﻮﺳﻂ ﻳﮏ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﻣﻴﺘﻮﺍﻥ ﻋﻨﺼﺮ ﮐﻤﻴﻨﻪ ﻭ ﺑﻴﺸﻴﻨﻪ ﻳﮏ ﺁﺭﺍﻳﻪ ﺭﺍ ﻣﺤﺴﺒﻪ ﮐﺮﺩ‪ .‬ﮐﺪ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺭ ﺯﻳﺮ ﺁﻭﺭﺩﻩ‬
‫ﺷﺪﻩ ﺍﺳﺖ‪:‬‬
٤٠ (Divide & Conquer)

‫و‬      ‫ش‬ ‫و‬ ‫ر‬

Procedure MinMax(A, l, u, min, max)

if l=u then
min←A(l)
max←A(l)
elsif l+1=u then
if A(l)<A(u) then
min←A(l)
max←A(u)
else
min←A(u)
max←A(l)
endif
else
mid ← (l+u)/2
call MinMax(A, l, mid, min1, max1)
call MinMax(A, l, mid+1, min2, max2)
if min1<min2 then
min←min1
else
min←min2
endif
if max1>max2 then
max←max1
else
max←max2
endif
endif
end.

 0 ;n =1
 1 ;n = 2
T ( n) = 
n
2T ( ) + 2 ; n > 2
 2
n n n
⇒ T (n) = 2[2T ( ) + 2] + 2 = 4T ( ) + 4 + 2 = 2 2 T ( 2 ) + 2 2 + 21
4 4 2
n
= 2 i T ( i ) + 2 i + 2 i −1 + L + 2 2 + 21
2
n =}2 k

= 2 k −1T (2) + 2 k −1 + L + 21
k −1 n 3n
= 2{ + 21k −42
1
+ L43 + 21 = + n − 2 = −2
n 2k −2
2 2
2
 ‫‪٤١‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫)‪(Strassen‬‬
‫ﺍ‬ ‫ﺍ‬ ‫ﺵ‬ ‫ﻪ‬
‫‪٢‬‬ ‫‪٤‬‬

‫ﻦ‬ ‫ﺳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﺳ‬ ‫ﻭ‬ ‫ﺭ‬ ‫ﺑ‬ ‫ﺲ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺗ‬ ‫ﺎ‬ ‫ﻣ‬ ‫ﻭ‬ ‫ﺩ‬ ‫ﺏ‬ ‫ﺮ‬ ‫ﺿ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺩﺭ ﺿﺮﺏ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ‪ ،n×n‬ﺧﺮﻭﺟﻲ ﺣﺎﺻﻞ ﻳﮏ ﻣﺎﺗﺮﻳﺲ ‪ n×n‬ﻣﻲﺑﺎﺷﺪ‪ ،‬ﻛﻪ ﺍﻳﻦ ﻣﺎﺗﺮﻳﺲ ﺩﺍﺭﺍﻱ ‪ n2‬ﻋﻀﻮ ﺍﺳـﺖ ﮐـﻪ‬
‫ﺑﺮﺍﻱ ﻫﺮ ﻋﻀﻮ ﺑﻪ ‪ n‬ﺿﺮﺏ ﻧﻴﺎﺯ ﺩﺍﺭﻳﻢ ﭘﺲ ﺗﻌﺪﺍﺩ ﺿﺮﺑﻬﺎﯼ ﻣﻮﺭﺩ ﻧﻴﺎﺯ ﺑﺮﺍﯼ ﺿﺮﺏ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ‪ O(n3) ،n×n‬ﻣﻲ ﺑﺎﺷﺪ‪.‬‬
‫ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺿﺮﺏ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ‪ n×n‬ﺭﺍ ﺑﻪ ﻭﺳﻴﻠﻪ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﺍﻧﺠﺎﻡ ﻣﻲﺩﻫﻴﻢ‪ ،‬ﮐﻪ ﻣﺮﺗﺒـﻪ ﺯﻣـﺎﻧﻲ ﺍﻳـﻦ ﺭﻭﺵ‬
‫ﻫﻢ )‪ O(n3‬ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬
‫ﺍﺑﺘﺪﺍ ﻫﺮ ﻣﺎﺗﺮﻳﺲ ﻭﺭﻭﺩﯼ ﺭﺍ ﺍﺯ ﺳﻄﺮ ﻭ ﺳﺘﻮﻥ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺗﺠﺰﻳﻪ ﻣﻴﮑﻨﻴﻢ ﺗﺎ ﻫﺮ ﻣـﺎﺗﺮﻳﺲ ﻭﺭﻭﺩﯼ ﺑـﻪ ‪ ۴‬ﺯﻳـﺮ ﻣـﺎﺗﺮﻳﺲ‬
‫ﺗﺠﺰﻳﻪ ﺷﻮﺩ‪.‬‬

‫‪ A11 A12   B11‬‬ ‫‪B12  C 11 C 12 ‬‬

‫‪‬‬ ‫‪‬‬ ‫‪=‬‬ ‫‪‬‬
‫‪ A 21 A 22   B 21‬‬ ‫‪B 22  C 21 C 22 ‬‬ ‫ﻫﺮ ﮐﺪﺍﻡ ﺍﺯ ﺯﻳﺮ ﻣﺎﺗﺮﻳﺴﻬﺎ ﺩﺍﺭﺍﯼ ‪ n/2‬ﺳﻄﺮ ﻭ ‪ n/2‬ﺳﺘﻮﻥ ﺍﺳﺖ ﮐﻪ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‬
‫ﻫﺮ ﺯﻳﺮ ﻣﺎﺗﺮﻳﺲ ﺩﺍﺭﺍﯼ ‪ n2/4‬ﺩﺭﺍﻳﻪ ﻣﻴﺒﺎﺷﺪ‪ .‬ﺑﺎ ﮐﻤﯽ ﺗﺎﻣﻞ ﻣﻴﺘﻮﺍﻥ ﺩﺭﻳﺎﻓﺖ ﮐـﻪ ﺗﻮﺳـﻂ ﺭﻭﺵ ﺯﻳـﺮ ﻣﻴﺘـﻮﺍﻥ ‪ ۴‬ﻗﺴـﻤﺖ ﺍﺯ‬
‫ﻣﺎﺗﺮﻳﺲ ﺣﺎﺻﻠﻀﺮﺏ ﺭﺍ ﺗﻮﻟﻴﺪ ﮐﺮﺩ ﮐﻪ ﺍﻳﻦ ﺭﻭﺵ ﻧﻴﺎﺯ ﺑﻪ ‪ ۸‬ﻓﺮﺍﺧـﻮﺍﻧﯽ ﺑﺎﺯﮔﺸـﺘﯽ ﺗـﺎﺑﻊ ﺩﺍﺭﺩ ﻭ ﻟـﺬﺍ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒـﻪ ﺯﻣـﺎﻧﯽ‬
‫)‪ O(n3‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪C11 = A11 ∗ B11 + A12 ∗ B 21‬‬

‫‪C12 = A11 ∗ B12 + A12 ∗ B 22‬‬
‫‪C 21 = A 21 ∗ B11 + A 22 ∗ B 21‬‬
‫‪C 22 = A 21 ∗ B12 + A 22 ∗ B 22‬‬

‫‪n‬‬ ‫‪n2‬‬ ‫‪‬‬ ‫‪‬‬

‫∗ ‪T ( n ) = 8T   + 4‬‬
‫‪8‬‬
‫‪= 0  n log 2‬‬ ‫‪=n‬‬
‫‪3‬‬
‫‪2‬‬ ‫‪4‬‬ ‫‪‬‬ ‫‪‬‬

‫ﺭﻭﺵ ﺍﺳﺘﺮﺍﺳﻦ‪ :‬ﻧﻮﺳﻂ ﻳﮏ ﺍﻳﺪﻩ ﺟﺎﻟﺐ ﻣﻴﺘﻮﺍﻥ ﻣﻌﺎﺩﻻﺕ ﺑﺎﻻ ﺭﺍ )ﮐﻪ ﻧﻴﺎﺯ ﺑـﻪ ‪ ۸‬ﺿـﺮﺏ ﻣﺎﺗﺮﻳﺴـﯽ ﻭ ‪ ۴‬ﺟﻤـﻊ ﻣﺎﺗﺮﻳﺴـﯽ‬
‫ﺩﺍﺷﺖ(ﺑﻪ ﮔﻮﻧﻪ ﺩﻳﮕﺮﯼ ﺑﺎﺯﻧﻮﻳﺴﯽ ﮐﺮﺩ ﮐﻪ ﻧﻴﺎﺯ ﺑﻪ ‪ ۷‬ﺿﺮﺏ ﻣﺎﺗﺮﻳﺴﯽ ﻭ ‪ ۱۸‬ﺟﻤﻊ ﻣﺎﺗﺮﻳﺴﯽ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬
‫‪ ٨‬ﺿﺮﺏ ﺭﺍ ﺑﻪ ‪ ٧‬ﺿﺮﺏ ﻭ ‪ ١٨‬ﺟﻤﻊ ﺗﺒﺪﻳﻞ ﻣﻲﻛﻨﺪ‪.‬‬
‫) ‪P1 = A11 ( B12 − B22‬‬
‫‪P2 = ( A11 + A12 ) B22‬‬
‫‪P3 = ( A21 + A22 ) B11‬‬
‫) ‪P4 = A22 ( B21 − B11‬‬
‫) ‪P5 = ( A11 + A22 )( B11 + B22‬‬
‫) ‪P6 = ( A12 − A22 )( B21 + B22‬‬
‫) ‪P7 = ( A11 − A21 )( B11 + B12‬‬
‫‪C11 = P5 + P4 − P2 + P6‬‬
‫‪C12 = P1 + P2‬‬
‫‪C 21 = P3 + P4‬‬
‫‪C 22 = P5 + P1 − P3 − P7‬‬

‫ﺑﻨﺎﺑﺮﺍﻳﻦ‪:‬‬
‫‪٤٢‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪n‬‬
‫‪T ( n ) = 7 T   + 18‬‬
‫‪n2‬‬ ‫‪‬‬ ‫‪‬‬
‫(‬ ‫)‬
‫‪7‬‬
‫‪= O  n log 2  = O n 2 81‬‬
‫‪ ‬‬
‫‪2‬‬ ‫‪4‬‬ ‫‪‬‬ ‫‪‬‬

‫ﻁ‬

‫‪٣‬‬ ‫‪٤‬‬

‫ﺎ‬ ‫ﻘ‬ ‫ﻧ‬ ‫ﺝ‬ ‫ﻭ‬ ‫ﺯ‬ ‫ﻦ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﻜ‬ ‫ﻳ‬ ‫ﺩ‬ ‫ﺰ‬ ‫ﻧ‬ ‫ﻦ‬ ‫ﻌ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻴ‬ ‫ﻴ‬

‫ﻘ‬ ‫ﻧ‬ ‫ﺝ‬ ‫ﻧ‬

‫‪١‬‬ ‫‪٣‬‬ ‫‪٤‬‬

‫ﻱ‬ ‫ﺑ‬ ‫ﻚ‬ ‫ﻱ‬ ‫ﺎ‬ ‫ﻀ‬ ‫ﻓ‬ ‫ﺎ‬ ‫ﺯ‬ ‫ﻴ‬ ‫ﻴ‬

‫ﻦ‬ ‫ﻦ‬

‫ﻳ‬ ‫ﻭ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﻜ‬ ‫ﻳ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺪ‬ ‫ﻌ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﻁ‬ ‫ﺩ‬ ‫ﺰ‬ ‫ﻌ‬

‫ﺩﺭﻓﻀﺎﻱ ﻳﻚ ﺑﻌﺪﻱ ﻓﻘﻂ ﻣﺤﻮﺭ‪ x‬ﺭﺍ ﺩﺍﺭﻳﻢ ﻛﻪ ﺑﺮ ﺭﻭﯼ ﺍﻳﻦ ﻣﺤﻮﺭ ﺗﻌﺪﺍﺩ ‪ n‬ﻧﻘﻄﻪ ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﯼ ﺩﺍﺩﻩ ﺷـﺪﻩ ﺍﺳـﺖ‪ .‬ﻭ‬
‫ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﻣﺎﺑﻴﻦ ﻧﻘﺎﻁ ﺍﺳﺖ‪.‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﻭﻝ‪:‬‬
‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺗﮏ ﺗﮏ ﻧﻘﺎﻁ ﺭﺍ ﺑﺎ ﺑﻘﻴﻪ ﻧﻘﺎﻁ ﺑﺮﺭﺳﯽ ﮐﺮﺩﻩ ﻭ ﻓﺎﺻﻠﻪ ﺁﻧﻬـﺎ ﺭﺍ ﻣﺤﺎﺳـﺒﻪ ﮐـﺮﺩﻩ ﻭ ﺑـﻴﻦ ﻓﻮﺍﺻـﻞ ﮐﻤﺘـﺮﻳﻦ ﺭﺍ‬
‫ﻣﺤﺎﺳﺒﻪ ﻣﻴﮑﻨﻴﻢ ﮐﻪ ﺩﺭ ﻧﺘﻴﺠﻪ ﻧﻴﺎﺯ ﺑﻪ )‪ O(n2‬ﻣﺤﺎﺳﺒﻪ ﺩﺍﺭﺩ‪.‬‬
‫) (‬
‫‪o n 2 ← ( n − 1) + ( n − 2 ) + ....... + 1‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﻭﻡ‪:‬‬
‫ﻣﻴﺘﻮﺍﻥ ﺍﺑﺘﺪﺍ ﻧﻘﺎﻁ ﺭﺍ ﺑﺮ ﺣﺴﺐ ﻣﺨﺘﺼﻪ ‪ x‬ﺷﺎﻥ ﻣﺮﺗﺐ ﮐﺮﺩﻩ ﻭ ﺳﭙﺲ ﺑﻴﻦ ﻓﻮﺍﺻﻞ ﻧﻘﺎﻁ ﻣﺘﻮﺍﻟﯽ ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﺭﺍ ﻣﺤﺎﺳﺒﻪ‬
‫ﮐﺮﺩ ﮐﻪ ﺩﺭ ﻧﺘﻴﺠﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪) O(n. log n‬ﺑﻪ ﺧﺎﻃﺮ ﻣﺮﺗﺐ ﺳﺎﺯﯼ( ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺳﻮﻡ)ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ(‪:‬‬
‫‪ -۱‬ﻧﻘﺎﻁ ﺭﺍ ﻣﺮﺗﺐ ﮐﻨﻴﺪ‬
‫‪ n/2 -۲‬ﻧﻘﺎﻁ ﺳﻤﺖ ﭼﭗ)‪ (pi; i=1,…,n/2‬ﺭﺍ ﺑﺼﻮﺭﺕ ﺑﺎﺯﮔﺸﺘﯽ ﺣﻞ ﮐﻨﻴﺪ)ﮐﻤﺘـﺮﻳﻦ ﻓﺎﺻـﻠﻪ ﺑـﻴﻦ ﺁﻧﻬـﺎ ﺭﺍ ‪s1‬‬
‫ﻣﻴﻨﺎﻣﻴﻢ(‬
‫‪ n/2 -۳‬ﻧﻘﺎﻁ ﺳﻤﺖ ﺭﺍﺳﺖ)‪ (qi; i=1,…,n/2‬ﺭﺍ ﺑﺼﻮﺭﺕ ﺑﺎﺯﮔﺸﺘﯽ ﺣﻞ ﮐﻨﻴﺪ)ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﺑـﻴﻦ ﺁﻧﻬـﺎ ﺭﺍ ‪s2‬‬
‫ﻣﻴﻨﺎﻣﻴﻢ(‬
‫‪ -۴‬ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﻧﻬﺎﻳﻲ ﺍﺯ ﺭﺍﺑﻄﻪ ﺯﻳﺮ ﻗﺎﺑﻞ ﺗﻮﻟﻴﺪ ﺍﺳﺖ‪:‬‬
‫{‬ ‫}‬
‫} ‪min = s1, s 2 , min {q i } − max { pi‬‬
‫‪n ‬‬
‫) ‪T ( n ) = 2T   + 1 = o (n‬‬
‫‪2‬‬

‫× × × ×‬ ‫× × × ×‬

‫‪S1‬‬
‫‪S2‬‬

‫درآ )‪
#( o(n log n‬د )&در ‪(sort +91‬‬
‫‪٤٣‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻘ‬ ‫ﻧ‬ ‫ﺝ‬ ‫ﻧ‬

‫‪٢‬‬ ‫‪٣‬‬ ‫‪٤‬‬

‫ﻱ‬ ‫ﺑ‬ ‫ﻱ‬ ‫ﺎ‬ ‫ﻀ‬ ‫ﻓ‬ ‫ﺎ‬ ‫ﺯ‬ ‫ﻴ‬ ‫ﻴ‬

‫ﻦ‬ ‫ﻦ‬

‫ﻭ‬ ‫ﻭ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﻜ‬ ‫ﻳ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺪ‬ ‫ﻌ‬ ‫ﺩ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﻁ‬ ‫ﺩ‬ ‫ﺰ‬ ‫ﻌ‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫‪ -۱‬ﺩﺭﺍﺑﺘﺪﺍ ﻧﻮﺩﻫﺎ ﺭﺍ ﺩﺭ ﺍﻳﻦ ﻓﻀﺎ ﺑﺮﺍﺳﺎﺱ ﻣﺨﺘﺼﻪ ‪ x‬ﺷﺎﻥ ﻣﺮﺗﺐ ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫‪ -۲‬ﺳﭙﺲ ﺑﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻳﮏ ﺧﻂ ﻓﺮﺿﯽ ﻣﺠﻤﻮﻋﻪ ﻧﻘﺎﻁ ﺭﺍ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﭼﭗ ﻭ ﺭﺍﺳﺖ ﮐﻪ ﻫـﺮ ﮐـﺪﺍﻡ ﺩﺍﺭﺍﯼ‬
‫‪ n/2‬ﻋﻨﺼﺮ ﻫﺴﺘﻨﺪ ﺗﻘﺴﻴﻢ ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫‪ -۳‬ﺩﻭ ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﭼﭗ ﻭ ﺭﺍﺳﺖ ﺭﺍ ﺣﻞ ﮐﺮﺩﻩ ﺗﺎ ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﺩﺭ ﻫﺮ ﺩﻭ ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﺗﻮﻟﻴﺪ ﺷﻮﺩ ﻭ ﺳﭙﺲ ﺟﻮﺍﺏ‬
‫ﺣﻞ ﺩﻭ ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﺭﺍ ‪ S1‬ﻭ ‪ S2‬ﻣﻴﻨﺎﻣﻴﻢ‪.‬‬
‫‪S=min(S1,S2) -۴‬‬
‫‪ -۵‬ﺣﺎﻝ ﺍﮔﺮ ﺷﺒﻴﻪ ﺭﻭﺵ ﻳﮏ ﺑﻌﺪﯼ ﻓﺎﺻﻠﻪ ﻧﺰﺩﻳﮑﺘﺮﻳﻦ ﻧﻘﻄﻪ ﺍﺯ ﻧﻘﺎﻁ ﭼﭗ ﻭ ﺭﺍﺳـﺖ ﺧـﻂ ﺭﺍ ﻧﻴـﺰ ﺩﺭ ﻣﺤﺎﺳـﺒﺎﺕ‬
‫ﺩﺧﻴﻞ ﮐﻨﻴﻢ ﻣﻤﮑﻦ ﺍﺳﺖ ﺑﻪ ﺟﻮﺍﺏ ﺻﺤﻴﺢ ﻧﺮﺳﻴﻢ‪ .‬ﻟﺬﺍ ﺩﺭ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺑﺎ ﺍﺿﺎﻓﻪ ﮐﺮﺩﻥ ﻳﮑﺴـﺮﻱ ﺷـﺮﺍﻳﻂ ﺳـﻌﻲ‬
‫ﻣﻲﮐﻨﻴﻢ ﺗﻌﺪﺍﺩ ﻣﻘﺎﻳﺴﻪ ﻫﺎ ﺭﺍ ﮐﻢ ﮐﻨﻴﻢ‪ .‬ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ‪ S‬ﺍﺯ ﺧﻂ ﻭﺳﻂ ﺍﺯ ﻫﺮ ﺩﻭ ﻃﺮﻑ ﻳﮏ ﻣﺤﺪﻭﺩﻩ ﺩﺭ ﻧﻈـﺮ‬
‫ﮔﺮﻓﺖ ﻭ ﻧﻘﺎﻁ ﺩﺍﺧﻞ ﺍﻳﻦ ﺑﺎﺭﻳﮑﻪ ﺭﺍ ﺑﺎ ﻫﻢ ﻣﻘﺎﻳﺴﻪ ﮐﺮﺩ ﮐﻪ ﺩﺭ ﻧﺘﻴﺠﻪ ﺑﺎﺯ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﺷـﺮﺍﻳﻂ ﺗﻤـﺎﻡ ‪ n/2‬ﻧﻘﻄـﻪ‬
‫ﺳﻤﺖ ﭼﭗ ﻭ ‪ n/2‬ﻧﻘﻄﻪ ﺳﻤﺖ ﺭﺍﺳﺖ ﺧﻂ ﻭﺳﻂ ﺩﺭ ﺍﻳﻦ ﺑﺎﺭﻳﮑﻪ ﻫﺎ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ﻭ ﻟﺬﺍ ﻣﺮﺗﺒـﻪ ﺯﻣـﺎﻧﯽ )‪O(n2‬‬
‫ﺧﻮﺍﻫﺪ ﺷﺪ ﻭﻟﯽ ﻣﻴﺘﻮﺍﻥ ﺑﺮﺍﯼ ﻫﺮ ﻧﻘﻄﻪ ﻭﺍﻗﻊ ﺩﺭ ﺑﺎﺭﻳﮑﻪ ﺳﻤﺖ ﭼﭗ ﻣﺎﻧﻨـﺪ ‪ p‬ﻓﻘـﻂ ﻧﻘـﺎﻁ ﻭﺍﻗـﻊ ﺩﺭ ﻣﺴـﺘﻄﻴﻞ‬
‫ﺧﺎﺻﯽ ﺭﺍ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ‪ .‬ﺍﻳﻦ ﻣﺴﺘﻄﻴﻞ ﺑﻪ ﺍﻳﻦ ﺻﻮﺭﺕ ﺳﺎﺧﺘﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ﺑﺎﻳﺪ ﭘﺎﻱ ﻋﻤﻮﺩ ﺍﺯ ﻧﻘﻄـﻪ ﻧﺴـﺒﺖ ﺑـﻪ‬
‫ﺧﻂ ﻭﺳﻂ ﺭﺍ ﭘﻴﺪﺍ ﮐﺮﺩﻩ ﺍﺯ ﺁﻥ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ‪ S‬ﺑﻪ ﺑﺎﻻ‪ ،‬ﭘﺎﻳﻴﻦ ﻭ ﺭﺍﺳﺖ ﺣﺮﮐﺖ ﮐﺮﺩ ﺗﺎ ﻳﮏ ﻧﺎﺣﻴﻪ ﻣﺴـﺘﻄﻴﻠﯽ ﺷـﮑﻞ‬
‫ﺑﻪ ﻃﻮﻝ ‪ 2S‬ﻭ ﻋﺮﺽ ‪ S‬ﺣﺎﺻﻞ ﺷﻮﺩ‪ .‬ﺑﺪﻳﻬﯽ ﺍﺳﺖ ﮐﻪ ﺣﺪﺍﮐﺜﺮ ﺗﻌﺪﺍﺩ ﻧﻘـﺎﻁ ﻭﺍﻗـﻊ ﺩﺭ ﺍﻳـﻦ ﻧﺎﺣﻴـﻪ ﻣﺴـﺘﻄﻴﻠﯽ‬
‫ﺷﮑﻞ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ ۶‬ﻧﻘﻄﻪ ﺍﺳﺖ! ﻭ ﻟﺬﺍ ﺑﺮﺍﯼ ﻫﺮ ﻧﻘﻄﻪ ﺩﺭ ﺑﺎﺭﻳﮑﻪ ﺳﻤﺖ ﭼﭗ ﻓﻘﻂ ﺑﺎﻳﺪ ﻓﺎﺻﻠﻪ ﺁﻥ ﺭﺍ ﺑﺎ ‪ ۶‬ﻧﻘﻄـﻪ ﺩﺭ‬
‫ﺑﺎﺭﻳﮑﻪ ﺳﻤﺖ ﺭﺍﺳﺖ ﻣﺤﺎﺳﺒﻪ ﮐﺮﺩ ﻭﺍﻳﻦ ﻓﻮﺍﺻﻞ ﺭﺍ ﻧﻴﺰ ﺩﺭ ﻣﺤﺎﺳﺒﻪ ﮐﻤﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﺩﺧﻴﻞ ﮐﺮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺑﺪﻟﻴﻞ ﺍﻳﻨﮑﻪ ﭘﻴﺎﺩﻩ ﺳﺎﺯﻱ ﺩﺍﻳﺮﻩ ﺍﻱ ﺑﺎ ﺷﻌﺎﻉ ‪ S‬ﻣﺸﮑﻞ ﺍﺳﺖ ﺍﺯ ﻳﮏ ﻣﺴﺘﻄﻴﻞ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲ ﮐﻨﻴﻢ‪.‬‬

‫ﻣﺤﺎﺳـﺒﻪ‬ ‫ﻧﮑﺘﻪ‪ :‬ﻓﺎﺻﻠﻪ ﺩﻭ ﻧﻘﻄﻪ )‪ (x1,y1‬ﻭ )‪ (x2,y2‬ﺩﺭ ﻓﻀﺎﯼ ﺩﻭ ﺑﻌـﺪﯼ ﺍﺯ ﺭﺍﺑﻄـﻪ ‪( x1 − x2 ) 2 + ( y1 − y 2 ) 2‬‬
‫ﻣﻴﺸﻮﺩ‪.‬‬

‫‪S‬‬ ‫‪S‬‬

‫‪S‬‬
‫‪S‬‬
‫‪p‬‬

‫‪S‬‬
‫‪S‬‬

‫‪S1‬‬ ‫‪S2‬‬
‫‪٤٤‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻭ ﻟﺬﺍ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﻗﺎﺑﻞ ﻣﺤﺎﺳﺒﻪ ﺍﺳﺖ‪:‬‬

‫‪n‬‬ ‫‪n‬‬
‫)‪T (n) = 2T ( ) + 6 = Ο(n. log n‬‬
‫‪2‬‬ ‫‪2‬‬

‫ﻪ‬ ‫ﻪ‬ ‫ﺍ‬ ‫ﻒ‬ ‫‪۴‬‬ ‫‪۴‬‬

‫ﺗ‬ ‫ﺎ‬ ‫ﺳ‬ ‫ﺎ‬ ‫ﻣ‬ ‫ﺳ‬ ‫ﻫ‬ ‫ﺭ‬ ‫ﺩ‬ ‫ﻳ‬ ‫ﺎ‬ ‫ﯼ‬ ‫ﺎ‬ ‫ﻬ‬ ‫ﺘ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﻭ‬ ‫ﻳ‬ ‫ﺭ‬ ‫ﺎ‬ ‫ﻌ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬

‫ﯽ‬ ‫ﺒ‬ ‫ﺤ‬ ‫ﺪ‬ ‫ﻨ‬ ‫ﭘ‬

‫ﭼﻨﺪﺿﻠﻌﻲ ﺑﺴﺘﻪ‪ :‬ﺩﻧﺒﺎﻟﻪﺍﻱ ﺍﺯ ﭘﺎﺭﻩﺧﻄﻬﺎ ﻛﻪ ﺍﻧﺘﻬﺎﻱ ﻫﺮﻛﺪﺍﻡ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺩﻳﮕﺮﻱ ﻭﺻـﻞ ﺑﺎﺷـﺪ ﻭ ﺿـﻤﻨﺎﹰ ﺑﺴـﺘﻪ ﺷـﻮﺩ ﻳﻌﻨـﻲ‬
‫ﺍﻧﺘﻬﺎﻱ ﺁﺧﺮﻱ ﺑﻪ ﺍﺑﺘﺪﺍﻱ ﺍﻭﻟﻲ ﻣﺘﺼﻞ ﺑﺎﺷﺪ‪.‬‬
‫ﭼﻨﺪ ﺿﻠﻌﯽ ﺳﺎﺩﻩ‪ :‬ﭼﻨﺪ ﺿﻠﻌﯽ ﺑﺴﺘﻪﺍﯼ ﮐﻪ ﺩﺭ ﺁﻥ ﻫﻴﭻ ﻳﺎﻟﻲ‪ ،‬ﻳﺎﻝ ﺩﻳﮕﺮﻱ ﺭﺍ ﻗﻄﻊ ﻧﻜﻨﺪ‪.‬‬
‫ﭼﻨﺪ ﺿﻠﻌﻲ ﻣﺤﺪﺏ‪ :‬ﭼﻨﺪﺿﻠﻌﻲ ﺳﺎﺩﻩﺍﯼ ﻛﻪ ﺯﺍﻭﻳﻪﺍﻱ ﺑﻴﺸﺘﺮ ﺍﺯ‪ ١٨٠‬ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ )ﻫﺮﺩﻭ ﻧﻘﻄﻪ ﺩﺍﺧﻞ ﭼﻨﺪﺿﻠﻌﻲ ﺭﺍ ﺑﻪ ﻫﻢ‬
‫ﻭﺻﻞ ﻛﻨﻴﻢ ﭘﺎﺭﻩﺧﻂ ﺣﺎﺻﻞ ﺩﺍﺧﻞ ﭼﻨﺪﺿﻠﻌﻲ ﺑﺎﺷﺪ‪(.‬‬
‫ﺟﻬﺖ ﭼﺮﺧﺶ ﺑﻴﻦ ﺳﻪ ﻧﻘﻄﻪ ﺩﺭ ﻓﻀﺎﯼ ‪ ۲‬ﺑﻌﺪﯼ‪:‬‬
‫)‪P1(x1,y1‬‬ ‫‪p1 , p 2 , p3‬‬
‫ ﺭﺍﺳﺖ ﮔﺮﺩ‬
‫)‪P2(x2,y2‬‬
‫‪  p 3 , p1 , p 2‬ﺭﺍﺳﺖ ﮔﺮﺩ‬

‫)‪P3(x3,y3‬‬ ‫‪  p 2 , p3 , p1‬ﺭﺍﺳﺖ ﮔﺮﺩ‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺟﻬﺖ ﺗﺸﺨﻴﺺ ﺭﺍﺳﺖﮔﺮﺩ ﻳﺎ ﭼﭗﮔﺮﺩ ﺑﻮﺩﻥ‬

‫ﺩﺗﺮﻣﻴﻨﺎﻥ ﻣﺎﺗﺮﻳﺲ ﺯﻳﺮ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩﻩ‪ ،‬ﺍﮔﺮ ﺑﺰﺭﮔﺘﺮ ﺍﺯ ﺻﻔﺮ ﺑﻮﺩ ﭼﭗﮔﺮﺩ ﺍﺳﺖ‪ ،‬ﺍﮔﺮ ﻛـﻮﭼﻜﺘﺮ ﺍﺯ ﺻـﻔﺮ ﺑـﻮﺩ ﺭﺍﺳـﺖﮔـﺮﺩ‬
‫ﺍﺳﺖ ﻭ ﺍﮔﺮ ﻣﺴﺎﻭﯼ ﺻﻔﺮ ﺑﻮﺩ ‪ ۳‬ﻧﻘﻄﻪ ﻫﻢ ﺧﻂ ﻫﺴﺘﻨﺪ‪.‬‬
‫‪x1‬‬ ‫‪y1 1‬‬
‫‪x2‬‬ ‫‪y2 1 > 0‬‬
‫‪x3‬‬ ‫‪y3 1‬‬
‫ﺗﺸﺨﻴﺺ ﭼﭗﮔﺮﺩ ﻭ ﺭﺍﺳﺖﮔﺮﺩ ﺩﺍﺭﺍﻱ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ  )‪o (1‬‬
‫ﻗﻀﻴﻪ‪ :‬ﻧﺤﻮﻩ ﺗﺸﺨﻴﺺ ﻣﺤﺪﺏ ﺑﻮﺩﻥ ﻳﻚ ﭼﻨﺪﺿﻠﻌﻲ‪:‬‬
‫ﺍﮔﺮ ﺗﻤﺎﻣﻲ ﺭﺃﺱﻫﺎﯼ ﻣﺘﻮﺍﻟﯽ ﻧﺴﺒﺖ ﺑﻪ ﺩﻭ ﺭﺍﺱ ﻗﺒـﻞ ﺍﺯ ﺧـﻮﺩ ﭼـﭗﮔـﺮﺩ ﻳـﺎ ﺭﺍﺳـﺖﮔـﺮﺩ ﺑﺎﺷـﺪ ﭼﻨﺪﺿـﻠﻌﻲ ﻣﺤـﺪﺏ‬
‫ﺍﺳﺖ‪o(n).‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﭼﮕﻮﻧﮕﻲ ﺗﺸﺨﻴﺺ ﻣﺘﻘﺎﻃﻊ ﺑﻮﺩﻥ ﺩﻭ ﭘﺎﺭﻩ ﺧﻂ‬

‫ﺩﻭ ﭘﺎﺭﻩ ﺧﻂ ‪ AB‬ﻭ ‪ CD‬ﺑﻪ ﻋﻨﻮﺍﻥ ﻭﺭﻭﺩﯼ ﺩﺍﺩﻩ ﺷﺪﻩﺍﻧﺪ‪ .‬ﺍﮔﺮ ‪ A‬ﻧﺴﺒﺖ ﺑﻪ ﺩﻭ ﻧﻘﻄﻪ ‪ C‬ﻭ ‪ D‬ﺭﺍﺳﺘﮕﺮﺩ ﻭ ‪ B‬ﻧﺴـﺒﺖ ﺑـﻪ‬
‫ﺩﻭ ﻧﻘﻄﻪ ‪ C‬ﻭ ‪ D‬ﭼﭙﮕﺮﺩ ﺑﺎﺷﺪ)ﻭ ﻳﺎ ﺑﺎﻟﻌﮑﺲ( ﻭ ﻫﻤﭽﻨﻴﻦ ‪ C‬ﻧﺴﺒﺖ ﺑﻪ ﺩﻭ ﻧﻘﻄﻪ ‪ A‬ﻭ ‪ B‬ﺭﺍﺳـﺘﮕﺮﺩ ﻭ ‪ D‬ﻧﺴـﺒﺖ ﺑـﻪ ﺩﻭ‬
‫ﻧﻘﻄﻪ ‪ A‬ﻭ ‪ B‬ﭼﭙﮕﺮﺩ ﺑﺎﺷﺪ)ﻭ ﻳﺎ ﺑﺎﻟﻌﮑﺲ( ﺁﻧﮕﺎﻩ ‪ AB‬ﻭ ‪ CD‬ﻣﺘﻘﺎﻃﻊ ﻫﺴﺘﻨﺪ ﻭ ﻟـﺬﺍ ﺑﺎﻳـﺪ ﺩﺭ ﺑـﺪﺗﺮﻳﻦ ﻭﺿـﻌﻴﺖ ‪ ٤‬ﺑـﺎﺭ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺗﺸﺨﻴﺺ ﺟﻬﺖ )ﺩﺗﺮﻣﻴﻨﺎﻥ ﺑﺎﻻ( ﻣﺤﺎﺳﺒﻪ ﺷﻮﺩ‪ .‬ﺍﺯ ﺍﻳﻦ ﺭﻭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(1‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪B‬‬ ‫‪D‬‬
‫‪A‬‬

‫‪C‬‬
‫‪٤٥‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﻧﺤﻮﻩ ﭘﻴﺪﺍﻛﺮﺩﻥ ﻳﻚ ﻧﻮﺩ ﺩﺍﺧﻞ ﭼﻨﺪ ﺿﻠﻌﻲ ﻣﺤﺪﺏ‬

‫ﺳﻪ ﺭﺃﺱ ﻣﺘﻮﺍﻟﻲ ﺭﺍ ﺑﻪ ﺩﻟﺨﻮﺍﻩ ﺍﻧﺘﺨﺎﺏ ﻣﻲﻛﻨﻴﻢ ﻣﻴﺎﻧﮕﻴﻦ ‪ x‬ﻫﺎﯼ ﺁﻧﻬﺎ ﻭ ﻣﻴﺎﻧﮕﻴﻦ ‪ y‬ﻫﺎﯼ ﺁﻧﻬﺎ )‪ (x,y‬ﻧﻘﻄﻪﺍﯼ ﺩﺍﺧـﻞ ﭼﻨـﺪ‬
‫ﺿﻠﻌﯽ ﻣﺤﺪﺏ ﺭﺍ ﺗﻮﻟﻴﺪ ﻣﻴﮑﻨﻨﺪ‪ .‬ﻟﺬﺍ ﺍﻳﻦ ﺭﻭﺵ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ )‪ o(1‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﺗﺸﺨﻴﺺ ﻳﻚ ﻧﻘﻄﻪ ﺩﺍﺧﻞ ﭼﻨﺪﺿﻠﻌﻲ ﻣﺤﺪﺏ‬

‫ﺍﮔﺮ ﺗﻤﺎﻡ ﺯﻭﺝ ﺭﺋﻮﺱ ﺍﺿﻼﻉ ﻣﺘﻮﺍﻟﯽ )ﺩﺭ ﺟﻬﺖ ﺧﻼﻑ ﭼﺮﺧﺶ ﻋﻘﺮﺑﻪ ﻫﺎﯼ ﺳﺎﻋﺖ( ﻧﺴﺒﺖ ﺑﻪ ﻧﻘﻄﻪ ﺟﺪﻳﺪ ﭼـﭗﮔـﺮﺩ‬
‫ﺑﻮﺩﻧﺪ ﻧﻘﻄﻪ ﺩﺍﺧﻞ ﭼﻨﺪﺿﻠﻌﻲ ﻣﻲﺑﺎﺷﺪ ﺩﺭ ﻏﻴﺮ ﺍﻳﻦﺻﻮﺭﺕ ﺧﺎﺭﺝ ﺁﻥ ﺍﺳﺖ‪ .‬ﻭ ﻟﺬﺍ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ﺯﻣﺎﻥ )‪ o(n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪*p‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪ :‬ﺗﺸﺨﻴﺺ ﻧﻘﻄﻪ ﺩﺍﺧﻞ ﭼﻨﺪﺿﻠﻌﻲ ﻣﻘﻌﺮ‬

‫ﻳﻚ ﻧﻘﻄﻪ ﺧﺎﺭﺝ ﭼﻨﺪﺿﻠﻌﻲ ﻣﻘﻌﺮ ﺍﻧﺘﺨﺎﺏ ﻣﻲﻛﻨﻴﻢ ﻭ ﺑﻪ ﻧﻘﻄﻪ ﻣﻮﺭﺩﻧﻈﺮ ﻭﺻﻞ ﻣﻲﻛﻨﻴﻢ ﺍﮔﺮ ﺗﻌﺪﺍﺩ ﺑﺮﺧﻮﺭﺩﻫـﺎ ﺑـﺎ ﻳﺎﻟﻬـﺎﻱ‬
‫ﭼﻨﺪﺿﻠﻌﻲ ﻓﺮﺩ ﺑﻮﺩ ﺩﺍﺧﻞ ﭼﻨﺪ ﺿﻠﻌﻲ ﻏﻴﺮ ﻣﺤﺪﺏ ﻣﻲﺑﺎﺷﺪ ﻭ ﺍﮔﺮ ﺯﻭﺝ ﺑﻮﺩ ﺧـﺎﺭﺝ ﺁﻥ ﺍﺳـﺖ‪ .‬ﻭ ﻟـﺬﺍ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ‬
‫ﺯﻣﺎﻥ )‪ o(n‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﺩﺭ ﺷﮑﻞ ﺯﻳﺮ ﺗﻌﺪﺍﺩ ﻧﻘﺎﻁ ﺗﻘﺎﻃﻊ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ ۷‬ﻣﻴﺒﺎﺷﺪ ﻭ ﻟﺬﺍ ﻧﻘﻄﻪ ﻣﻮﺭﺩ ﻧﻈﺮ ﺩﺭ ﺩﺍﺧﻞ ﺷﮑﻞ ﻗﺮﺍﺭ ﺩﺍﺭﺩ‪.‬‬

‫‪) :Convex hull‬ﭘﻮﺳﺘﻪ ﻳﺎ ﭘﻮﺵ ﻣﺤﺪﺏ(‪ .‬ﻛﻮﭼﻜﺘﺮﻳﻦ ﭼﻨﺪ ﺿﻠﻌﻲ ﻣﺤﺪﺏ ﻛﻪ ﺷﺎﻣﻞ ﻫﻤﻪ ﻧﻘﺎﻁ ﻭﺭﻭﺩﯼ ﺑﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪:‬ﺑﺮﺍﯼ ﺗﺼﻮﺭ ﺷﮑﻞ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﻣﻴﺘﻮﺍﻥ ﻓﺮﺽ ﮐﺮﺩ ﮐﻪ ﺗﻌﺪﺍﺩﻱ ﻧﻘﻄﻪ ﺩﺍﺭﻳﻢ ﻭ ﻳﻚ ﻛـﺶ ﺣﻠﻘـﻮﯼ ﺭﺍ ﺑـﺎﺯﻛﺮﺩﻩ ﺩﻭﺭ‬
‫ﻧﻘﺎﻁ ﻗﺮﺍﺭ ﻣﻴﺪﻫﻴﻢ‪ .‬ﺷﮑﻞ ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﺗﻮﺳﻂ ﮐﺶ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‪.‬‬
‫‪٤٦‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪ :Extreme point‬ﻧﻘﺎﻃﻲ ﺭﺍ ﻛﻪ ﺭﻭﻱ ‪ convexhull‬ﻫﺴﺘﻨﺪ ﻧﻘﺎﻁ ﻣﺮﺯﻱ ﻣﻲﮔﻮﻳﻴﻢ‪.‬‬

‫ﻧﮑﺘﻪ‪:‬‬
‫ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﻭﺿﻌﻴﺖ ‪ convex hull‬ﺷﺎﻣﻞ ﺗﻤﺎﻡ ‪ n‬ﻧﻘﻄﻪ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﺩﺭ ﺑﻬﺘﺮﻳﻦ ﻭﺿﻌﻴﺖ ‪convex hull‬ﻓﻘﻂ ﺷﺎﻣﻞ ‪ ۳‬ﻧﻘﻄﻪ ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﻣﺴﺌﻠﻪ ﻣﻮﺯﻩ ﻫﻨﺮﻱ‪ :‬ﻧﺤﻮﻩ ﻃﺮﺍﺣﻲ ﻳﻚ ﻣﻮﺯﻩ ﺑﻪ ﻗﺴﻤﻲ ﻛﻪ ﺑﻪ ﻛﻤﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﻧﮕﻬﺒﺎﻥ ﺟﻬﺖ ﺭﻭﻳﺖ ﺍﺣﺘﻴﺎﺝ ﺑﺎﺷﺪ‪.‬‬

‫ﺣﻞ ﻣﺴﺌﻠﻪ‪ :‬ﺩﺭ ﺩﺭﺟﻪ ﺍﻭﻝ ﺑﻬﺘﺮ ﺍﺳﺖ ﻛﻪ ‪ convex hull‬ﺑﺎﺷﺪ‪.‬‬

‫ﺩﺭﺻﻮﺭﺗﻲﻛﻪ ﻃﺮﺍﺣﻲ ﻣﻘﻌﺮ ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﺑﻪ ﺷﻜﻞ ‪ Star shaped‬ﺑﺎﺷﺪ ﺗﺎ ﻳﻚ ﻧﮕﻬﺒﺎﻥ‬
‫‪kernel‬‬
‫ﺑﺮﺍﻱ ﻛﻞ ﻣﻮﺯﻩ ﻛﺎﻓﻲ ﻣﻲﺑﺎﺷﺪ‪..‬‬
‫‪ :Kernel‬ﻓﻀﺎﻳﻲ ﺩﺭ ﭼﻨﺪ ﮐﻪ ﺍﺯ ﺁﻥ ﻓﻀﺎ ﻛﻞ ﭼﻨﺪﺿﻠﻌﻲ ﺩﻳﺪﻩ ﻣﻲﺷﻮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺩﺭ ‪ convex hull‬ﻛﻞ ﺁﻥ ‪ kernel‬ﺍﺳﺖ‪.‬‬

‫ﻣﺴﺌﻠﻪ ﺭﻭﺷﻨﺎﻳﻲ‪ :‬ﺩﺭ ‪ convex hull‬ﻳﻚ ﻻﻣﭗ ﺑﺮﺍﻱ ﺭﻭﺷﻨﺎﻳﻲ ﻛﺎﻓﻲ ﺍﺳﺖ ﻭ ﻣﻮﻗﻌﻴﺖ ﻻﻣﭗ ﺍﻫﻤﻴـﺖ ﻧـﺪﺍﺭﺩ ﺩﺭ ‪Star‬‬
‫‪ shaped‬ﻳﻚ ﻻﻣﭗ ﺑﺮﺍﻱ ﺭﻭﺷﻨﺎﻳﻲ ﻛﺎﻓﻲ ﺍﺳﺖ ﺩﺭ ﺻﻮﺭﺗﻲ ﻛﻪ ﺩﺭ ﺩﺍﺧﻞ ‪ kernel‬ﻗﺮﺍﺭ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬

‫ﺩﺭ ﺷﻜﻞ ﻣﻘﺎﺑﻞ ﺍﺯ ﻳﻚ ﻻﻣﭗ ﻛﻪ ﺑﻪ ﺷﻜﻞ ﻣﻴﻠﻪ ﻣﻲﺑﺎﺷﺪ ﺟﻬـﺖ‬

‫ﺭﻭﺷﻦ ﻛﺮﺩﻥ ﻛﻞ ﭼﻨﺪ ﺿﻠﻌﻲ ﻣﻘﻌﺮﺍﺳﺘﻔﺎﺩﻩ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺤﺎﺳﺒﻪ ‪convexhull‬‬

‫ﺩﻭ ﺭﻭﺵ ﻣﻮﺭﺩ ﺑﺤﺚ ﻗﺮﺍﺭ ﻣﻴﮕﻴﺮﺩ‪:‬‬
‫‪(Greedy) Graham -١‬‬
‫‪(D & C) Shamos -٢‬‬
‫‪٤٧‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫)‪(Convex Hull‬‬
‫ﺵ‬
‫‪٤‬‬

‫‪٥‬‬

‫ﺏ‬ ‫ﻣ‬ ‫ﻮ‬ ‫ﻟ‬ ‫ﻮ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺪ‬ ‫ﺤ‬ ‫ﭘ‬ ‫ﺪ‬ ‫ﻴ‬

‫‪Graham‬‬
‫‪١‬‬ ‫‪٤‬‬

‫‪٥‬‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫‪ -۱‬ﺩﺭ ﺍﺑﺘﺪﺍ ﻧﻮﺩﻱ ﺭﺍ ﻛﻪ ﺩﺍﺭﺍﻱ ﻛﻤﺘﺮﻳﻦ ‪ y‬ﻣﻲﺑﺎﺷﺪ ﭘﻴﺪﺍ ﻣﻲﻛﻨﻴﻢ ﻭ ﺁﻥ ﺭﺍ ‪ p1‬ﻣﻴﻨﺎﻣﻴﻢ‪.‬‬

‫‪ -۲‬ﻣﺎﺑﻘﯽ ﻧﻮﺩﻫﺎ ﺭﺍ ﻧﺴﺒﺖ ﺑﻪ ﺍﻳﻦ ﻧﻮﺩ ﺑﺮﺍﺳﺎﺱ ﺯﺍﻭﻳﻪ ﻗﻄﺒﻲ ﺩﺭ ﺟﻬﺖ ﺧﻼﻑ ﻋﻘﺮﺑﻪﻫﺎﯼ ﺳﺎﻋﺖ ﻣﺮﺗﺐ ﻣﻲﻛﻨـﻴﻢ ﻭ‬
‫ﺁﻧﻬﺎ ﺭﺍ ‪ p2‬ﺗﺎ ‪ pn‬ﻧﺎﻣﮕﺬﺍﺭﯼ ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫‪ P1 -۳‬ﻭ ‪ p2‬ﺭﺍ ﺩﺍﺧﻞ ﻳﮏ ﭘﺸﺘﻪ ﻗﺮﺍﺭ ﺩﺍﺩﻩ ﻭ ﺳﭙﺲ ﭼﭗﮔﺮﺩ ﺑﻮﺩﻥ ﺑﻘﻴﻪ ﻧﻮﺩﻫﺎ ﺭﺍ ﺑﺎ ﺩﻭ ﻧﻘﻄﻪ ﺳـﺮ ﭘﺸـﺘﻪ ﺑﺮﺭﺳـﻲ‬
‫ﻣﻲﻛﻨﻴﻢ‪ .‬ﺍﮔﺮ ﺟﻬﺖ ﭼﭗﮔﺮﺩ ﺑﻮﺩ ﻧﻘﻄﻪ ﻣﻮﺭﺩ ﺑﺮﺭﺳﯽ ﺭﺍ ﺑﻪ ﭘﺸﺘﻪ ﺍﺿﺎﻓﻪ ﻣﻴﮑﻨﻴﻢ ﺩﺭﻏﻴﺮﺍﻳﻨﺼﻮﺭﺕ ﻳـﮏ ﻧﻘﻄـﻪ ﺍﺯ‬
‫ﺳﺮ ﭘﺸﺘﻪ ﺣﺬﻑ ﺷﺪﻩ ﻭ ﺩﻭﺑﺎﺭﻩ ﺑﺮﺭﺳﯽ ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﻴﻢ‪.‬‬

‫‪Procedure Graham‬‬
‫‪p1  find the point with minimum y‬‬
‫‪Sort the other points around p1 (CCW –Polar angle) and call them p2 ,…, pn‬‬
‫)‪Push (p1‬‬
‫)‪Push (p2‬‬
‫‪For i3 to n do‬‬
‫‪While Right (stack [top-1] , stack[top], Pi) do‬‬
‫‪Pop‬‬
‫‪Repeat‬‬
‫)‪Push (pi‬‬
‫‪repeat‬‬
‫‪End.‬‬

‫ﺳﺮﺷﻜﻦ ﺷﺪﻥ ﻫﺰﻳﻨﻪ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬

‫ﺑﻴﺸﺘﺮﻳﻦ ﺗﮑﺮﺍﺭ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﻣﺮﺑﻮﻁ ﺑﻪ ‪ pop‬ﻣﻴﺒﺎﺷﺪ ﮐﻪ ﺑﺮﺧﻼﻑ ﭼﻴﺰﻱ ﻛﻪ ﺩﺭ ﻇﺎﻫﺮ ﻧﺸـﺎﻥ ﻣـﻲﺩﻫـﺪ ﺩﺍﺭﺍﻱ ﻣﺮﺗﺒـﻪ‬
‫ﺯﻣﺎﻧﻲ )‪ o(n2‬ﻧﻴﺴﺖ ﺑﻠﮑﻪ )‪ o(n‬ﺍﺳﺖ ﺯﻳﺮﺍ ﻳﻚ ﻧﻘﻄﻪ ﺑﻴﺸﺘﺮ ﺍﺯ ﻳﻚ ﺑﺎﺭ ﻧﻤﻲﺗﻮﺍﻧﺪ ‪ pop‬ﻳﺎ ‪ push‬ﺷـﻮﺩ ﻭ ﭼـﻮﻥ ﻣﺮﺗﺒـﻪ‬
‫ﺯﻣﺎﻧﻲ ﻣﺮﺗﺐ ﺳﺎﺯﯼ )‪ O(n logn‬ﺍﺳﺖ‪ .‬ﻟﺬﺍ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ )‪ O(n logn‬ﺍﺳﺖ‪.‬‬
‫‪٤٨‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪Shamos‬‬
‫‪٢‬‬ ‫‪٤‬‬

‫‪٥‬‬

‫ﻢ‬ ‫ﺘ‬ ‫ﻳ‬

‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬

‫ﺭ‬ ‫ﻮ‬ ‫ﮕ‬ ‫ﻟ‬ ‫ﺍ‬

‫‪ -۱‬ﻧﻘﺎﻁ ﺭﺍ ﺑﻪ ﺩﻭ ﺩﺳﺘﻪ ﮐﻪ ﻫﺮ ﺩﺳﺘﻪ ﺷﺎﻣﻞ ‪ n/2‬ﻧﻘﻄﻪ ﺍﺳﺖ ﺗﻘﺴﻴﻢ ﻣﻴﮑﻨﻴﻢ‪.‬‬

‫‪ -۲‬ﻫﺮ ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﺭﺍ ﺑﺼﻮﺭﺕ ﺑﺎﺯﮔﺸﺘﯽ ﺣﻞ ﻣﻴﮑﻨﻴﻢ ﻭﻟﺬﺍ ﺑﺮﺍﯼ ﻫﺮ ﮐﺪﺍﻡ ﻳﮏ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﺗﻮﻟﻴﺪ ﻣﻴﺸﻮﺩ‪ .‬ﺍﻳﻦ ﺩﻭ‬
‫ﭘﺴﺘﻪ ﺭﺍ ‪ C1‬ﻭ ‪ C2‬ﻣﻴﻨﺎﻣﻴﻢ‪.‬‬
‫‪ -۳‬ﻳﮏ ﻧﻘﻄﻪ ﺩﺍﺧﻞ ‪ C1‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻭ ﺁﻥ ﺭﺍ ‪ p‬ﻣﻴﻨﺎﻣﻴﻢ‪.‬‬
‫‪ -۴‬ﺍﮔﺮ ‪ p∈C2‬ﺁﻧﮕﺎﻩ )ﻧﻘﻄﻪ ‪ p‬ﻫﻢ ﺩﺍﺧﻞ ‪ C1‬ﻭ ﻫﻢ ﺩﺍﺧﻞ ‪ C2‬ﺍﺳﺖ(‪ :‬ﺩﻭ ﻣﺠﻤﻮﻋﻪ ﺍﺯ ﻧﻘـﺎﻁ ‪ C1‬ﻭ ‪ C2‬ﺣـﻮﻝ ‪p‬‬
‫ﮐﻪ ﻳﮏ ﻧﻘﻄﻪ ﺩﺍﺧﻠﯽ ﺍﺳﺖ ﻣﺮﺗﺐ ﻫﺴﺘﻨﺪ ﻟﺬﺍ ﻣﻴﺘﻮﺍﻥ ﺁﻧﻬـﺎ ﺭﺍ ﺍﺩﻏـﺎﻡ ﮐـﺮﺩﻩ ﻭ ﺳـﭙﺲ ﻗﺴـﻤﺖ ﺳـﻮﻡ ﺍﻟﮕـﻮﺭﻳﺘﻢ‬
‫ﮔﺮﺍﻫﺎﻡ ﺭﺍ ﺭﻭﯼ ﺁﻧﻬﺎ ﺍﺟﺮﺍ ﮐﺮﺩ‪.‬‬
‫‪ -۵‬ﺍﮔﺮ ‪ p∉C2‬ﺁﻧﮕﺎﻩ ﺩﻭ ﻧﻘﻄﻪ ﻣﻤﺎﺳﯽ ﺍﺯ ‪ p‬ﻧﺴﺒﺖ ﺑﻪ ‪ C2‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﮐﺮﺩﻩ ﻟﺬﺍ ‪ C2‬ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﭘﻮﺳﺘﻪ ﺩﺍﺧﻠـﯽ‬
‫ﺯﺍﻭﻳﻪ ﻣﻤﺎﺳﯽ ﻭ ﭘﻮﺳﺘﻪ ﺧﺎﺭﺟﯽ ﺯﻟﻮﻳﻪ ﻣﻤﺎﺳﯽ ﺗﻘﺴﻴﻢ ﻣﻴﺸﻮﺩ‪ .‬ﻧﻘﺎﻁ ﻗﺴﻤﺖ ﺩﺍﺧﻠـﯽ ﺯﺍﻭﻳـﻪ ﻣﻤﺎﺳـﯽ ﺍﺯ ‪ C2‬ﺭﺍ‬
‫ﺣﺬﻑ ﮐﺮﺩﻩ ﻭ ﻟﺬﺍ ﻧﻘﺎﻁ ﻗﺴﻤﺖ ﺧﺎﺭﺟﯽ ﺯﺍﻭﻳﻪ ﻣﻤﺎﺳﯽ ﺍﺯ ‪ C2‬ﻭ ﮐﻞ ﻧﻘﺎﻁ ‪ C1‬ﺣﻮﻝ ‪ p‬ﻣﺮﺗﺐ ﻫﺴﺘﻨﺪ ﺑﺎ ﺍﺩﻏﺎﻡ‬
‫ﺁﻧﻬﺎ ﻭ ﺍﺟﺮﺍﯼ ﻗﺴﻤﺖ ﺳﻮﻡ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮔﺮﺍﻫﺎﻡ ﻣﻴﺘﻮﺍﻥ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﻧﻬﺎﻳﻲ ﺭﺍ ﺗﺸﮑﻴﻞ ﺩﺍﺩ‪.‬‬
‫‪n‬‬
‫)‪T (n) = 2T ( ) + cn = Ο(n. log n‬‬
‫‪2‬‬

‫ﺍﺷﮑﺎﻝ ﺯﻳﺮ ﺩﻭ ﺣﺎﻟﺖ ﻣﺨﺘﻠﻒ ﮐﻪ ﺑﺮﺍﯼ ﻧﻘﻄﻪ ‪ p‬ﻗﺎﺑﻞ ﺗﺼﻮﺭ ﺍﺳﺖ ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‪.‬‬

‫‪C2‬‬
‫‪C1‬‬

‫‪p‬‬

‫=<‪; - 2‬‬

‫‪C2‬‬
‫‪C1‬‬

‫‪p‬‬
‫‪٤٩‬‬ ‫)‪(Divide & Conquer‬‬
‫
‬ ‫و‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﻧﻬﺎﻳﻲ ﺑﻪ ﺷﮑﻞ ﺯﻳﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪.‬‬

 ‫‪۵‬‬

‫)‪(Dynamic Programming‬‬ ‫ﺎ‬ ‫ﻳ‬ ‫ﻮ‬ ‫ﭘ‬ ‫ﯼ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﺳ‬
‫ﻪ‬ ‫ﻣ‬

‫ﺎ‬
‫ﻧ‬

‫ﺮ‬ ‫ﺑ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬ ‫‪-‬‬

‫ﺩﺭ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﺩﻳﺪﻳﻢ ﻛﻪ ﺍﺑﺘﺪﺍ ﺍﺯ ﻣﺴﺌﻠﻪ ﺍﺻﻠﻲ ﺷﺮﻭﻉ ﮐﺮﺩﻩ ﻭ ﺁﻥ ﺭﺍ ﺑﻪ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﻛﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ ﻣـﻲﻛﻨـﻴﻢ ﻭ‬
‫ﻛﺎﺭ ﺭﺍ ﺗﺎ ﺣﺪ ﻣﻤﻜﻦ ﭘﻴﺶ ﻣﻲﺑﺮﻳﻢ ﻭ ﺳﭙﺲ ﺍﺯ ﺍﻧﺘﻬﺎ ﺑﻪ ﺍﺑﺘﺪﺍ ﻣﺴﺎﺋﻞ ﺭﺍ ﺣﻞ ﻣـﻲﻛﻨـﻴﻢ‪ .‬ﺩﺭ ﻭﺍﻗـﻊ ﺑـﺮﺍﻱ ﺷﻜﺴـﺘﻦ ﻣﺴـﺎﺋﻞ‬
‫ﺍﻟﮕﻮﻱ ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ )‪ (top down‬ﻭ ﺩﺭ ﺗﺮﻛﻴـﺐ ﺟﻮﺍﺑﻬـﺎ ﺍﻟﮕـﻮﻱ ﭘـﺎﻳﻴﻦ ﺑـﻪ ﺑـﺎﻻ ﺭﻋﺎﻳـﺖ ﻣـﻲﮔـﺮﺩﺩ ﻛـﻪ ﻣﻨﻄﺒـﻖ ﺑـﺮ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢﻫﺎﻱ ﺑﺎﺯﮔﺸﺘﻲ ﺍﺳﺖ‪ .‬ﺍﻣﺎ ﺍﮔﺮ ﺩﺭ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ ﻻﺯﻡ ﺑﺎﺷﺪ ﺯﻳﺮ ﻣﺴﺄﻟﻪ ﺧﺎﺻﻲ ﺭﺍ ﭼﻨﺪﻳﻦ ﻣﺮﺗﺒﻪ ﺣـﻞ ﻛﻨـﻴﻢ‬
‫ﺍﻳﻦ ﺗﻜﺮﺍﺭ ﻛﺎﺭﺁﻳﻲ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﭘﺎﻳﻴﻦ ﻣﻲﺁﻭﺭﺩ‪ .‬ﺍﮔﺮ ﭼﻨﻴﻦ ﺯﻳﺮﻣﺴﺄﻟﻪﺍﻱ ﺭﺍ ﻳﻚ ﺑﺎﺭ ﺣﻞ ﻛﺮﺩﻩ ﻭ ﺟﻮﺍﺏ ﺁﻧﻬـﺎ ﺭﺍ ﻧﮕﻬـﺪﺍﺭﻱ‬
‫ﻛﻨﻴﻢ‪ ،‬ﻣﻲﺗﻮﺍﻧﻴﻢ ﺩﺭ ﻣﺮﺍﺣﻞ ﺑﻌـﺪﻱ ﺍﺯ ﺁﻥ ﺍﺳـﺘﻔﺎﺩﻩ ﻛﻨـﻴﻢ ﻭ ﺍﻳـﻦ ﺍﺳـﺎﺱ ﻛـﺎﺭ ﺭﻭﺵ ﺣـﻞ ﻣﺴـﺎﺋﻠﻲ ﺍﺳـﺖ ﻛـﻪ ﺑـﻪ ﺭﻭﺵ‬
‫ﺑﺮﻧﺎﻣﻪﺳﺎﺯﻱ ﭘﻮﻳﺎ ﺣﻞ ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺍﺯ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻣﺴﺎﺋﻞ ﺷﺮﻭﻉ ﻭ ﻫﻤﻪ ﺁﻧﻬﺎ ﺭﺍ ﺣﻞ ﻣﻲﻛﻨﻴﻢ ﻭ ﺟﻮﺍﺏ ﺁﻧﻬﺎ ﺭﺍ ﻧﮕﻬﺪﺍﺭﻱ ﻣـﻲﻛﻨـﻴﻢ‪ .‬ﺳـﭙﺲ ﺑـﻪ‬
‫ﺳﻄﺢ ﺑﻌﺪﻱ ﻣﻲﺭﻭﻳﻢ ﻭ ﻛﻠﻴﻪ ﻣﺴﺎﺋﻞ ﺍﻧﺪﻛﻲ ﺑﺰﺭﮔﺘﺮ ﺭﺍ ﺣﻞ ﻣﻲﻛﻨﻴﻢ ﻭ ﺳﭙﺲ ﺑﻪ ﺣﻞ ﻣﺴﺎﺋﻞ ﺳﻄﺢ ﺑﻌـﺪﻱ ﻣـﻲﭘـﺮﺩﺍﺯﻳﻢ ﻭ‬
‫ﻛﺎﺭ ﺭﺍ ﺗﺎ ﺟﺎﻳﻲ ﺍﺩﺍﻣﻪ ﻣﻲﺩﻫﻴﻢ ﻛﻪ ﻣﺴﺄﻟﻪ ﺍﺻﻠﻲ ﺣﻞ ﺷﻮﺩ‪ .‬ﺑﺮﺍﻱ ﺣﻞ ﻫﺮﻳﻚ ﺍﺯ ﻣﺴﺎﺋﻞ ﻫﺮ ﺳﻄﺢ ﻣﻲﺗـﻮﺍﻧﻴﻢ ﺍﺯ ﺣـﻞ ﻛﻠﻴـﻪ‬
‫ﺳﻄﻮﺡ ﭘﺎﻳﻴﻦﺗﺮ ﻛﻪ ﻻﺯﻡ ﺑﺎﺷﺪ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ‪ .‬ﺍﺯ ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﺯﻣﺎﻧﯽ ﻣﻴﺘﻮﺍﻥ ﺍﺳـﺘﻔﺎﺩﻩ ﮐـﺮﺩ ﮐـﻪ ﺍﺻـﻞ ﺑﻬﻴﻨﮕـﯽ‬
‫ﺑﺮﻗﺮﺍﺭ ﺑﺎﺷﺪ‪ .‬ﺍﻳﻦ ﺍﺻﻞ ﺑﺮ ﺍﻳﻦ ﺍﺳﺎﺱ ﺍﺳﺖ ﮐﻪ ﺑﺮﺍﯼ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺼﻮﺭﺕ ﺑﻬﻴﻨـﻪ ﺍﺯ ﺣـﻞ ﺑﻬﻴﻨـﻪ ﺯﻳـﺮ ﻣﺴـﺎﺋﻞ ﺁﻥ ﻣﻴﺘـﻮﺍﻥ‬
‫ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ‪ .‬ﺩﺭ ﺍﺩﺍﻣﻪ ﭼﻨﺪ ﻣﺴﺄﻟﻪ ﺭﺍ ﻛﻪ ﺑﺪﻳﻦ ﺭﻭﺵ ﺣﻞ ﻣﻲﺷﻮﻧﺪ ﺑﺮﺭﺳﻲ ﻣﻲﻛﻨﻴﻢ‪.‬‬

‫ﺑﺮﻧﺎﻣﻪﺳﺎﺯﻱ ﭘﻮﻳﺎ ﺩﺭ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﺭﻭﺵ ﺗﻘﺴﻴﻢ ﻭ ﺣﻞ‪ :‬ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ ﺭﺍ ﺍﺯ ﭘﺎﻳﻴﻦ ﺑﻪ ﺑﺎﻻ ﻣﻲﺳﺎﺯﻳﻢ ﻭ ﻧﺘﺎﻳﺞ ﺭﺍ ﺩﺭ ﻳـﻚ‬
‫ﺟﺪﻭﻝ ﻧﮕﻬﺪﺍﺭﻱ ﻣﻲﻛﻨﻴﻢ ﺗﺎ ﺩﺭ ﻣﻮﻗﻊ ﻟﺰﻭﻡ ﺑﺘﻮﺍﻥ ﺍﺯ ﺁﻧﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ ﻭ ﺩﻭﺑﺎﺭﻩ ﺁﻧﻬﺎ ﺭﺍ ﺣﻞ ﻧﮑﺮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻧﻮﻋﯽ ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﺩﺭ ﺁﻥ ﺯﻳﺮ ﻓﻀﺎﯼ ﺣﻞ ﻣﺴﺌﻠﻪ ﺍﺯ ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﺍﺳﺖ ﻭﻟﯽ ﺯﻳﺮ ﻣﺴﺎﺋﻞ‬
‫ﺣﻞ ﺷﺪﻩ ﺩﺭ ﺟﺪﻭﻟﯽ ﻧﮕﻬﺪﺍﺭﯼ ﻣﻴﺸﻮﻧﺪ ﺗﺎ ﺍﺯ ﺣﻞ ﺯﻳﺮ ﻣﺴﺎﺋﻞ ﺗﮑﺮﺍﺭﯼ ﭘﺮﻫﻴـﺰ ﺷـﻮﺩ ﮐـﻪ ﺍﻳـﻦ ﺭﻭﺵ ﺑـﻪ ﻧـﺎﻡ ﺭﻭﺵ ﺑـﻪ‬
‫ﺧﺎﻃﺮﺳﭙﺎﺭﯼ )‪ (memoized‬ﺷﻨﺎﺧﺘﻪ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﺍﺻﻞ ﺑﻬﻴﻨﮕﻲ‪ :‬ﺍﻧﺘﺨﺎﺏ ﺑﻬﻴﻨﻪ ﻧﻬﺎﻳﻲ ﺑﻪ ﺍﻧﺘﺨﺎﺑﻬﺎﻱ ﺑﻬﻴﻨﻪ ﺍﻭﻟﻴﻪ ﺑﺴﺘﮕﻲ ﺩﺍﺭﺩ‪.‬‬
‫ﺑﺮﺍﯼ ﺍﺭﺍﺋﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ‪ ۴‬ﻣﺮﺣﻠﻪ ﺭﺍ ﺑﺎﻳﺪ ﻃﺮﺍﺣﯽ ﮐﺮﺩ‪:‬‬
‫‪ -۱‬ﺗﻌﺮﻳﻒ ﺗﺎﺑﻌﯽ ﮐﻪ ﺣﻞ ﺗﺎﺑﻊ ﻣﻨﺠﺮ ﺑﻪ ﺣﻞ ﻣﺴﺌﻠﻪ ﺷﻮﺩ‪.‬‬
‫‪ -۲‬ﺑﻴﺎﻥ ﺷﺮﺍﻳﻂ ﻣﺮﺯﯼ‬
‫‪ -۳‬ﺑﻴﺎﻥ ﺟﻮﺍﺏ ﻣﺴﺌﻠﻪ ﺑﺮ ﺣﺴﺐ ﺗﺎﺑﻊ‬
‫‪ -۴‬ﺗﻌﺮﻳﻒ ﺑﺎﺯﮔﺸﺘﯽ ﺗﺎﺑﻊ‬
‫‪٥١‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪0/1‬‬
‫ﻪ‬ ‫ﻪ‬
‫‪١‬‬

‫‪٥‬‬

‫ﺘ‬ ‫ﺸ‬ ‫ﻟ‬ ‫ﻮ‬ ‫ﻛ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻲ‬ ‫ﭘ‬ ‫ﻠ‬ ‫ﺌ‬

‫ﻣﺴﺌﻠﻪ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﺻﻔﺮ ﻳﺎ ﻳﮏ ﻣﺪﻟﯽ ﺍﺯ ﻣﺴﺌﻠﻪ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﺁﻥ ﺍﺷﻴﺎﺀ ﻳﺎ ﺑﻄﻮﺭ ﮐﺎﻣـﻞ ﺍﻧﺘﺨـﺎﺏ ﻣﻴﺸـﻮﻧﺪ ﻭ ﻳـﺎ‬
‫ﺍﻧﺘﺨﺎﺏ ﻧﻤﻴﺸﻮﻧﺪ ﻭ ﻧﻤﻴﺘﻮﺍﻥ ﻓﻘﻂ ﮐﺴﺮﯼ ﺍﺯ ﺍﺷﻴﺎﺀ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩ‪.‬‬
‫ﻭﺭﻭﺩﻱ‪:‬‬
‫‪ :n‬ﺗﻌﺪﺍﺩ ﮐﻴﺴﻪ ﻫﺎ‬
‫‪ :Pi‬ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺍﻧﺘﺨﺎﺏ ﻛﻞ ﺟﺴﻢ ‪ i‬ﺍﹸﻡ‬
‫‪ :Wi‬ﻭﺯﻥ ﻛﻞ ﺟﺴﻢ ‪ i‬ﺍﹸﻡ‬
‫‪ :M‬ﮔﻨﺠﺎﻳﺶ ﻛﻮﻟﻪ ﭘﺸﺘﯽ‬
‫‪n‬‬
‫ﻫﺪﻑ‪ :‬ﺑﻴﺸﻴﻨﻪ ﮐﺮﺩﻥ ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺍﻧﺘﺨﺎﺏ ﺍﺟﻨﺎﺱ ﻳﻌﻨﯽ ‪Max ∑ xi . pi‬‬
‫‪i =1‬‬

‫ﺷﺮﺍﻳﻂ ﻣﺴﺌﻠﻪ‪:‬‬
‫ﻭﺯﻥ ﻫﻤﻪ ﮐﻴﺴﻪﻫﺎ ﺭﻭﻱ ﻫﻢ ﺍﺯ ﻭﺯﻥ ﻛﻮﻟﻪﭘﺸﺘﻲ ﺑﻴﺸﺘﺮ ﺍﺳﺖ ﺯﻳﺮﺍ ﺍﮔﺮ ﻛﻤﺘﺮ ﺑﺎﺷـﺪ ﻳﻌﻨـﻲ ﻣـﻲﺗـﻮﺍﻧﻴﻢ ﻫﻤـﻪ ﺭﺍ ﺑـﺮﺩﺍﺭﻳﻢ ﻭ‬
‫ﺍﻧﺘﺨﺎﺑﻲ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﻫﻤﭽﻨﻴﻦ ﻣﺠﻤﻮﻉ ﻭﺯﻥ ﺍﺟﺴﺎﻣﻲ ﻛﻪ ﺍﻧﺘﺨﺎﺏ ﻛﺮﺩﻳﻢ ﺍﺯ ﻭﺯﻥ ﻛﻞ ﻛﻮﻟﻪﭘﺸﺘﻲ ﻧﺒﺎﻳﺪ ﺑﻴﺸﺘﺮ ﺷﻮﺩ‪.‬‬
‫‪n‬‬

‫‪∑w‬‬ ‫‪i >M‬‬

‫‪i =1‬‬ ‫‪-١‬‬
‫‪n‬‬

‫‪∑x w‬‬ ‫‪i‬‬ ‫‪i ≤M‬‬

‫‪i =1‬‬ ‫‪-٢‬‬

‫ﺧﺮﻭﺟﻲ‪ :‬ﻛﺴﺮﻱ ﺍﺯ ﮐﻴﺴﻪ ‪ i‬ﺍﹸﻡ ﻛﻪ ﺍﻧﺘﺨﺎﺏ ﻣﻲﺷﻮﺩ ﺩﺍﺧﻞ ﻋﻨﺼﺮ ‪ i‬ﺍﻡ ﺁﺭﺍﻳﻪ ﻗﺮﺍﺭ ﻣﻲﮔﻴﺮﺩ‪.‬‬
‫‪ = Xi‬ﮐﺴﺮﯼ ﺍﺯ ﮐﻴﺴﻪ ‪ i‬ﺍﻡ ﮐﻪ ﺍﻧﺘﺨﺎﺏ ﻣﻴﺸﻮﺩ‪(i=1,…,n) ( Xi =0 or 1) .‬‬
‫ﺭﺍﻩ ﺣﻞ‪ :‬ﺗﻮﺳﻂ ﻣﺜﺎﻟﻬﺎﯼ ﻧﻘﻀﯽ ﻣﻴﺘﻮﺍﻥ ﻧﺸﺎﻥ ﺩﺍﺩ ﮐﻪ ﺍﻧﺘﺨﺎﺏ ﮐﻴﺴﻪ ﻫﺎ ﺑﺮ ﺍﺳﺎﺱ ﻣﻌﻴﺎﺭ ﻣﻄﺮﺡ ﺷﺪﻩ ﺩﺭ ﻣﺴﺌﻠﻪ ﮐﻮﻟﻪ ﭘﺸـﺘﯽ‬
‫ﮐﺴﺮﯼ ﻣﻤﮑﻦ ﺍﺳﺖ ﺑﻪ ﺟﻮﺍﺏ ﺑﻬﻴﻨﻪ ﻣﻨﺠﺮ ﻧﺸﻮﺩ‪ .‬ﺗﻮﺳﻂ ﻣﺜﺎﻝ ﻧﻘﻀﯽ ﻣﻴﺘﻮﺍﻥ ﺍﻳﻦ ﻣﻮﺿﻮﻉ ﺭﺍ ﻧﺸﺎﻥ ﺩﺍﺩ‪.‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪i+1‬‬ ‫‪n‬‬

‫‪...........‬‬ ‫‪.......‬‬
‫‪٥٢‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫‪ :gi(y) -۱‬ﺑﻴﺸﺘﺮﻳﻦ ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺣﻞ ﻣﺴﺄﻟﻪ ﺑﺮﺍﻱ ﺟﺴﻢ ‪ i+1‬ﺍﹸﻡ ﺗﺎ ‪ n‬ﺍﹸﻡ ﺑـﻪ ﺷـﺮﻃﻲ ﻛـﻪ ﮔﻨﺠـﺎﻳﺶ ﻛﻮﻟـﻪ ‪y‬‬
‫ﺑﺎﺷﺪ‪.‬‬
‫‪ g0(M) -۲‬ﺑﻴﺸﺘﺮﻳﻦ ﺳﻮﺩ ﺣﺎﺻﻞ ﺍﺯ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺮﺍﻱ ﻛﻞ ﺍﺟﺴﺎﻡ ﺑﻪ ﺷﺮﻃﻲ ﻛﻪ ﮔﻨﺠﺎﻳﺶ ﻛﻮﻟﻪ ‪ M‬ﺑﺎﺷﺪ‪.‬‬
‫‪ -۳‬ﺷﺮﺍﻳﻂ ﻣﺮﺯﻱ‪:‬‬
‫) (‬
‫‪) ، g n y = 0‬ﺍﺯ ﺟﺴﻢ‪ n+1‬ﺑﻪ ﺑﻌﺪ ﺟﺴﻤﻲ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﻛﻪ ﺳﻮﺩﻱ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ(‬
‫) ‪gi ( y‬‬
‫ﺣﺎﻟـﺖ ﺿـﺮﺭ ﺍﺳـﺖ‪.‬‬ ‫‪ ،y<0‬ﮔﻨﺠﺎﻳﺶ ﻛﻮﻟﻪ ﻣﻨﻔﻲ ﻣﻲﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺑﻴﺸﺘﺮ ﺍﺯ ﺣﺪ ﻛﻮﻟﻪ ﺟﺴﻢ ﺩﺍﺭﻳﻢ ﺩﺭ ﺍﻳﻦ ﺣﺎﻟـﺖ‬
‫∞‪( g i ( y ) ) = −‬‬
‫‪g i ( y ) = Max{g i +1 ( y ), pi +1 + g i +1 ( y − wi +1 )} -۴‬‬

‫ﻣﺜﺎﻝ‪ :‬ﻣﺴﺌﻠﻪ ﺯﻳﺮ ﺭﺍ ﺑﻪ ﺑﻪ ﮐﻤﮏ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺣﻞ ﻛﻨﻴﺪ؟‬

‫‪P ٢٠ ١٠ ٣٠‬‬
‫‪w ١٢ ١٠ ١٣‬‬

‫‪M=30‬‬ ‫)‪g0(30‬‬
‫{‬ ‫}‬
‫‪g 0 ( 30 ) = Max g1 ( 30 ) , 20 + g1 (18 ) = 50‬‬
‫)‪g1(30‬‬ ‫)‪g1(18‬‬
‫‪g1 ( 30 ) = Max { g 2 ( 30 ) ,10 + g 2 ( 20 )} = 40‬‬

‫‪g1 (18 ) = Max { g 2 (18 ) ,10 + g 2 ( 8 )} = 30‬‬ ‫)‪g2(30‬‬ ‫)‪g2(20‬‬ ‫)‪g2(18‬‬ ‫)‪g2(5‬‬
‫‪g 2 ( 30 ) = Max { g 3 ( 30 ) ,30 + g 3 (17 )} = 30‬‬

‫‪g 2 ( 20 ) = Max { g 3 ( 20 ) ,30 + g 3 ( 7 )} = 30‬‬

‫)‪g3(30‬‬ ‫)‪g3(17‬‬ ‫)‪g3(20) g3(7‬‬
‫‪g 2 (18 ) = Max { g 3 (18 ) ,30 + g 3 ( 5 )} = 30‬‬

‫‪g 2 ( 8 ) = Max { g 3 ( 8 ) ,30 + g 3 ( −5 )} = 0‬‬

‫‪g‬‬ ‫‪-‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪Y‬‬ ‫‪M-1‬‬ ‫‪M‬‬

‫‪0‬‬ ‫∞‪-‬‬ ‫ﺟﻮﺍﺏ‬
‫‪1‬‬ ‫∞‪-‬‬
‫∞‪-‬‬
‫‪i‬‬ ‫∞‪-‬‬ ‫)‪gi(y‬‬
‫∞‪-‬‬
‫‪n-1‬‬ ‫∞‪-‬‬
‫‪n‬‬ ‫∞‪-‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪٥٣‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻧﮑﺘﻪ ﺍﺳﺎﺳﯽ ﺩﺭ ﺭﻭﺵ ﻣﺤﺎﺳﺒﻪ ﻣﺎﺗﺮﻳﺲ ﺟﻮﺍﺏ ﺩﺭ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﺑﻪ ﮐﺪﺍﻡ ﻳﮏ ﺍﺯ ﺭﻭﺷﻬﺎﯼ ﺯﻳـﺮ ﻣﻴﺘـﻮﺍﻥ ﻣـﺎﺗﺮﻳﺲ ﺭﺍ ﭘـﺮ‬
‫ﮐﺮﺩ‪ .‬ﺑﺎ ﮐﻤﯽ ﺩﻗﺖ ﺩﺭ ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺟﻮﺍﺏ ﺭﺳﻴﺪ‪.‬‬

‫‬ ‫‬ ‫‬ ‫‬ ‫‬

‫)‪function DP_knapsack(W,P,n,M‬‬
‫‪for i←0 to M do g[n,i] ←0 repeat‬‬
‫‪for i←0 to n do g[-,i] ←-∞ repeat‬‬
‫‪for i=n-1 to 0‬‬
‫‪for j=0 to m‬‬
‫} ]‪g[i,j] =max{g[i+1,y],pi+1+g[i+1,y-Wi+1‬‬
‫‪repeat‬‬
‫‪repeat‬‬
‫]‪return g[0,M‬‬
‫‪end.‬‬
‫ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ )‪ o(M.n‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺑﺎ ﺍﻳﻨﮑﻪ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺩﺭ ﻇﺎﻫﺮ ﭼﻨﺪﺟﻤﻠﻪﺍﯼ ﺍﺳﺖ ﻭﻟﯽ ﭼﻮﻥ ﻓﻘﻂ ﺑـﻪ ﺗﻌـﺪﺍﺩ ﺍﻗـﻼﻡ ﻭﺭﻭﺩﯼ ﻭﺍﺑﺴـﺘﻪ‬
‫ﻧﻴﺴﺖ ﺑﻠﮑﻪ ﺑﻪ ﺣﺠﻢ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﻫﻢ ﻭﺍﺑﺴﺘﻪ ﺍﺳﺖ ﻟﺬﺍ ﺑﻪ ﺁﻥ ﺷﺒﻪ ﭼﻨﺪ ﺟﻤﻠﻪﺍﯼ )‪ (pseudo polynomial‬ﮔﻮﻳﻨﺪ‪.‬‬

‫(‬ ‫)‬

‫‪APSP‬‬
‫ﻪ‬ ‫ﻪ‬
‫‪٢‬‬

‫‪٥‬‬

‫ﺎ‬ ‫ﻫ‬ ‫ﺮ‬ ‫ﺴ‬ ‫ﻣ‬ ‫ﻦ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺘ‬ ‫ﻫ‬ ‫ﺎ‬ ‫ﺗ‬ ‫ﻮ‬ ‫ﻛ‬ ‫ﻫ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬

‫ﻴ‬ ‫ﻠ‬ ‫ﺌ‬

‫ﻣﺴﺌﻠﻪ ﺩﻳﮕﺮﯼ ﮐﻪ ﺍﺯ ﺩﺳﺘﻪ ﻣﺴﺎﺋﻞ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺑﺮ ﺭﻭﯼ ﮔﺮﺍﻑ ﺍﺳـﺖ‪ ،‬ﻣﺴـﺌﻠﻪ ﻫﻤـﻪ ﮐﻮﺗـﺎﻫﺘﺮﻳﻦ ﻣﺴـﻴﺮﻫﺎ ‪(All‬‬
‫)‪ Pairs Shortest Paths‬ﻣﻴﺒﺎﺷﺪ ﮐﻪ ﻫﺪﻑ ﺁﻥ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﻃﻮﻝ ﮐﻮﺗـﺎﻫﺘﺮﻳﻦ ﻣﺴـﻴﺮ ﺑـﻴﻦ ﻫﻤـﻪ ﺯﻭﺝ ﺭﺋـﻮﺱ ﮔـﺮﺍﻑ‬
‫ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﺩﺭﺍﻳﻦ ﺭﻭﺵ ﻣﺎ ﺗﻤﺎﻡ ﻣﺴﻴﺮﻫﺎﻱ ﻣﻤﻜﻦ ﺍﺯ ﻫﺮ ﺭﺃﺳﻲ ﺭﺍ ﺑﻪ ﻫﺮ ﺭﺃﺱ ﺩﻳﮕﺮ ﻛﻪ ﺍﺯ ﺭﺃﺱ ‪ k‬ﺑﮕﺬﺭﺩ ﻳـﺎ ﻧﮕـﺬﺭﺩ ﺭﺍ ﻣﺤﺎﺳـﺒﻪ‬
‫ﻣﻲﻛﻨﻴﻢ ﺗﺎ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺑﺪﺳﺖ ﺁﻳﺪ ﻭ ﺧﻮﺩ‪ k‬ﺍﺯ ﻳﻚ ﺗﺎ‪ n‬ﺗﻐﻴﻴﺮ ﻣﻲﻛﻨﺪ‪ .‬ﻭ ﻭﻗﺘﻲ ‪ k=n‬ﺷﺪ ﻣﺎ ﺗﻤﺎﻡ ﺣـﺎﻻﺕ ﻣﻤﻜـﻦ‬
‫ﺑﺮﺍﻱ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩﻳﻢ‪) .‬ﺟﻮﺍﺏ= )‪ ( A(i,j‬ﻭ ﻭﻗﺘﻲ ‪ k=0‬ﺍﺳﺖ ﻳﻌﻨﻲ ﺍﺯ ﻫﻴﭻ ﺭﺃﺱ ﻋﺒـﻮﺭ ﻧﻤـﻲﻛﻨـﻴﻢ‬
‫ﻣﺴﺘﻘﻴﻤﺎﹰ ﺍﺯ ﺭﺃﺱ ‪ i‬ﺑﻪ ‪ j‬ﻣﻲﺭﻭﻳﻢ ﻛﻪ ﻫﻤﺎﻥ )‪ cost(i,j‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺩﺭ ﺻﻮﺭﺗﻲﻛﻪ ﻣﺴﻴﺮ ﺍﺯ ‪ i‬ﺑﻪ ‪ j‬ﻭﺟﻮﺩ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﺍﺭﺯﺵ ﻳﺎﻟﻬﺎﻱ ﺁﻥ ﺑﺮﺍﻱ ∞ ﻣﻲﺷﻮﺩ‪.‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ‪:‬‬
‫=)‪Ak(i,j‬‬
‫‪
C‬ل ‪
B‬ه‪ @A +‬از راس ‪ 2& i‬راس ‪ 2B ;-A, 2& j‬از ر‪
F‬س & ‪-#‬ر‪D& E‬ر‪ 1‬از ‪H1 IJ k‬ر "ا‪G@#& 2#‬‬
‫=)‪An(i,j‬‬
‫‪
L‬اب‬
‫)‪A0(i,j)=cost(i,j‬‬
‫‪٥٤‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻋﺒﺎﺭﺕ ﺯﻳﺮ ﺑﻴﺎﻥ ﺑﺎﺯﮔﺸﺘﯽ ﺗﻮﺿﻴﺤﺎﺕ ﺑﺎﻻ ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫{‬ ‫}‬
‫) ‪A k (i, j ) = min A k −1 (i, j ), A k −1 (i, k ) + A k −1 (k , j‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺑﺮﺍﻱ ﻣﺤﺎﺳﺒﻪ ) ‪ A (i, j‬ﺩﻭ ﺣﺎﻟﺖ ﭘﻴﺶ ﻣﻲﺁﻳﺪ‪ .‬ﻳﺎ ﻣﺴﻴﺮ ﺑﻬﻴﻨﻪ ﺍﺯ ﺭﺍﺱ ‪ k‬ﻣﻴﮕـﺬﺭﺩ ﮐـﻪ ﺩﺭ ﻧﺘﻴﺠـﻪ ﻣﺴـﻴﺮ ﺑـﻪ ﺩﻭ‬
‫‪k‬‬

‫ﻗﺴﻤﺖ ‪ i→k‬ﻭ ‪ k→j‬ﻗﺎﺑﻞ ﺗﻘﺴﻴﻢ ﺍﺳﺖ)ﮐﻪ ﻫﻴﭻ ﮐﺪﺍﻡ ﺍﺯ ﺍﻳﻦ ﺩﻭ ﻣﺴﻴﺮ ﺭﺍﺱ ﺑﺎ ﺷﻤﺎﺭﻩ ﺑﺰﺭﮔﺘﺮ ﺍﺯ ‪ k-1‬ﻧﺪﺍﺭﻧﺪ( ﻭﻳـﺎ ﺍﺯ‬
‫ﺭﺍﺱ ‪ k‬ﻧﻤﻴﮕﺬﺭﻳﻢ ﮐﻪ ﺩﺭ ﻧﺘﻴﺠﻪ ﮐﻠﻴﻪ ﺭﺋﻮﺱ ﻧﻤﻴﺘﻮﺍﻧﻨﺪ ﺍﺯ ‪ k-1‬ﺑﺰﺭﮔﺘﺮ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﺣﺎﻝ ﺍﮔﺮ ﻣﺎ ﺑﺘﻮﺍﻧﻴﻢ ) ‪ A (i, j‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﻢ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ‪،‬‬

‫‪n‬‬

‫ﻣﺴﻴﺮ ﺍﺯ ‪ i → j‬ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻧﻤﻮﺩﻩﺍﻳﻢ‪.‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﻮﺭﺩ ﺑﺤﺚ ﺑﻪ ﻧﺎﻡ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ floyd‬ﻣﻌﺮﻭﻑ ﺍﺳﺖ ﮐﻪ ﺷﺒﻪ ﮐﺪ ﺁﻥ ﺭﺍ ﺩﺭ ﺯﻳﺮ ﻣﻴﺒﻴﻨﻴﻢ‪:‬‬

‫)‪procedure APSP_Floyd(cost,n,A‬‬
‫‪for i←1 to n do‬‬
‫‪for j←1 to n do‬‬
‫]‪A[i,j] ←cost[i,j‬‬
‫‪p[i,j] ←0‬‬
‫‪repeat‬‬
‫‪repeat‬‬
‫‪for k←1 to n do‬‬
‫‪for i←1 to n do‬‬
‫‪for j←1 to n do‬‬
‫}]‪A[i,j] ←min{A[i,j],A[i,k]+A[k,j‬‬ ‫)*(‬
‫‪repeat‬‬
‫‪repeat‬‬
‫‪repeat‬‬
‫‪end.‬‬
‫ﺗﻮﻟﻴﺪ ﻣﺴﻴﺮ‪ :‬ﺍﮔﺮ ﺩﺭ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺟﻤﻠﻪ )*( ﺭﺍ ﺑﺎ ﺟﻤﻠﻪ ﺯﻳﺮ ﺟﺎﻳﮕﺰﻳﻦ ﮐﻨﻴﻢ ﺁﻧﮕﺎﻩ ﻋﻨﺼﺮ ]‪ P[i,j‬ﻫﻤﻴﺸﻪ ﺭﺍﺱ ﻣﻴﺎﻧﯽ ﺑﻴﻦ‬
‫ﺩﻭ ﺭﺍﺱ ‪ i‬ﻭ ‪ j‬ﺭﺍ ﺩﺭﺑﺮﺩﺍﺭﺩ ﻭ ﻟﺬﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﮐﻤﮏ ﻣﺎﺗﺮﻳﺲ ‪ p‬ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﻫﺎ ﺭﺍ ﺗﻮﻟﻴﺪ ﮐﺮﺩ‪:‬‬
‫‪if A[i,k]+A[k,j]<A[i,j] then‬‬
‫]‪A[i,j] ←A[i,k]+A[k,j‬‬
‫‪p[i,j] ←k‬‬
‫‪endif‬‬

‫ﻭﺍﺿﺢ ﺍﺳﺖ ﮐﻪ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ )‪ O(n3‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫‪٥٥‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫)‪(Catalan Number‬‬
‫ﻪ‬ ‫ﺍ‬

‫‪٣‬‬

‫ﻥ‬ ‫ﻼ‬

‫‪٥‬‬

‫ﺘ‬ ‫ﺴ‬ ‫ﺑ‬ ‫ﻭ‬ ‫ﻞ‬ ‫ﺋ‬ ‫ﺎ‬ ‫ﺴ‬ ‫ﻣ‬ ‫ﻭ‬ ‫ﺗ‬ ‫ﺎ‬ ‫ﮐ‬ ‫ﺩ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺪ‬ ‫ﻋ‬

‫ﺣﺎﻝ ﺑﻪ ﺑﺮﺭﺳﻲ ﭼﻨﺪ ﻣﺴﺌﻠﻪ ﻛﻪ ﻫﻤﮕﯽ ﺁﻧﻬﺎ ﺩﺍﺭﺍﻱ ﭘﺎﺳﺦﻫﺎﻱ ﻳﻜﺴﺎﻥ ﻣﻲﺑﺎﺷﻨﺪ‪ ،‬ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬
‫‪ -١‬ﺑﺎ ‪ n‬ﮔﺮﻩ ﭼﻨﺪ ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﻣﻲﺗﻮﺍﻥ ﺳﺎﺧﺖ؟‬
‫ﻣﺜﺎﻝ‪ :‬ﺑﺎ ﺳﻪ ﮔﺮﻩ ﭼﻨﺪ ﺩﺭﺧﺖ ﺩﻭﺩﻭﺋﻲ ﻣﻲﺗﻮﺍﻥ ﺳﺎﺧﺖ؟‬

‫)‪(١‬‬ ‫)‪(٢‬‬ ‫)‪(٣‬‬ ‫)‪(٤‬‬ ‫)‪(٥‬‬

‫‪ -٢‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ‪ n+1‬ﻳﻚ ﻣﺎﺗﺮﻳﺲ ﺭﺍ ﺩﺭ ﻫﻢ ﺿﺮﺏ ﻛﺮﺩ؟‬

‫ﻣﺜﺎﻝ‪ :‬ﺑﻪ ﭼﻨﺪﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ‪ ٤‬ﻣﺎﺗﺮﻳﺲ ﺭﺍ ﺩﺭﻫﻢ ﺿﺮﺏ ﻛﺮﺩ؟‬
‫‪1−‬‬ ‫) ‪((( m1 × m 2 ) × m3 ) m 4‬‬
‫) ‪2 − ( ( m1 × ( m 2 × m 3 ) ) × m 4‬‬

‫(‬
‫) ‪3 − ( m1 × m 2 ) × ( m 3 × m 4‬‬ ‫)‬
‫) ) ‪4 − ( m1 × ( ( m 2 × m 3 ) × m 4‬‬

‫) ) ) ‪5 − ( m1 × ( m 2 × ( m 3 × m 4‬‬

‫‪ -٣‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ‪ n‬ﻭﺭﻭﺩﻱ ﺭﺍ ﺑﻪ ﮐﻤﮏ ﻳﮏ ﭘﺸﺘﻪ ﺩﺭ ﺧﺮﻭﺟﯽ ﭼﺎﭖ ﮐﺮﺩ ﺑﻪ ﻗﺴﻤﯽ ﮐﻪ ﻓﻘﻂ ﻋﻤﻠﻴـﺎﺕ ‪،read‬‬
‫‪ push،write‬ﻭ ‪ pop‬ﻗﺎﺑﻞ ﺍﻧﺠﺎﻡ ﺍﺳﺖ؟‬
‫ﻣﺜﺎﻝ‪ ٣ :‬ﻭﺭﻭﺩﻱ ‪ a,b,c‬ﺭﺍ ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ﺩﺭ ﺧﺮﻭﺟﯽ ﭼﺎﭖ ﮐﺮﺩ؟‬

‫و‪;L‬‬ ‫ورود‪M‬‬
‫‪abc‬‬ ‫‪abc‬‬
‫‪acb‬‬
‫‪bac‬‬
‫‪bca‬‬
‫‪cba‬‬ ‫‪2NO‬‬

‫ﻣﻼﺣﻈﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ‪ ۳‬ﻭﺭﻭﺩﯼ ﺭﺍ ﺑﻪ ‪ ۵‬ﻃﺮﻳﻖ ﻣﻴﺘﻮﺍﻥ ﺩﺭ ﺧﺮﻭﺟﯽ ﻗﺮﺍﺭ ﺩﺍﺩ‪.‬‬

‫‪ -٤‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ﻳﻚ ‪ n+2‬ﺿﻠﻌﻲ ﻣﺤﺪﺏ ﺭﺍ ﻣﺜﻠﺚﺑﻨﺪﻱ ﻛﺮﺩ؟‬
‫ﺍﺑﺘﺪﺍ ﺗﻌﺮﻳﻔﯽ ﺍﺯ ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﺍﺭﺍﺋﻪ ﻣﻴﺪﻫﻴﻢ‪ .‬ﺍﮔﺮ ‪ P‬ﻳﮏ ﭼﻨﺪﺿﻠﻌﯽ ﻣﺤﺪﺏ ﺑﺎﺷﺪ‪ ،‬ﻣﺜﻠﺚ ﺑﻨﺪﯼ ‪ ، P‬ﺍﺿﺎﻓﻪ ﮐﺮﺩﻥ ﻗﻄﺮﻫﺎﻳﻲ‬
‫ﻏﻴﺮ ﻣﺘﻘﺎﻃﻊ ﺩﺭ ﺩﺍﺧﻞ ‪ P‬ﺍﺳﺖ ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﮐﻪ ‪ P‬ﺑﻪ ﺗﻌﺪﺍﺩﯼ ﻣﺜﻠﺚ ﺍﻓﺮﺍﺯ ﮔﺮﺩﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺜﻠﺚ ﺑﻨﺪﯼ ‪ P‬ﻣﻨﺠﺮ ﺑﻪ ﺭﺳﻢ ﺑﻴﺸﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﺍﻗﻄﺎﺭ ﺩﺍﺧﻞ ‪ P‬ﻣﻴﺸﻮﺩ ﺑﻪ ﻗﺴﻤﯽ ﮐﻪ ﺍﻗﻄﺎﺭ ﻳﮑﺪﻳﮕﺮ ﺭﺍ ﻗﻄﻊ ﻧﮑﻨﻨﺪ‪.‬‬
‫‪٥٦‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻣﺜﺎﻝ‪ :‬ﻳﻚ ‪ ٥‬ﺿﻠﻌﻲ ﻣﺤﺪﺏ ﺭﺍ ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ﻣﺜﻠﺚﺑﻨﺪﻱ ﻛﺮﺩ؟‬

‫ﻣﻼﺣﻈﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ﻳﮏ ‪ ۵‬ﺿﻠﻌﯽ ﻣﺤﺪﺏ ﺭﺍ ﺑﻪ ‪ ۵‬ﻃﺮﻳﻖ ﻣﻴﺘﻮﺍﻥ ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﮐﺮﺩ‪.‬‬

‫‪ -٥‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ﺩﺭ ﻳﮏ ﮔﺮﻳﺪ ﮐﻪ ﺩﺍﺭﺍﯼ ‪ n‬ﺳﻄﺮ ﻭ ‪ n‬ﺳﺘﻮﻥ ﺍﺳﺖ‪ ،‬ﺍﺯ ﭘﻮﺷﻪ ﭘﺎﻳﻴﻦ ﺳﻤﺖ ﭼﭗ ﺑﻪ ﮔﻮﺷﻪ ﺑـﺎﻻ‬
‫ﺳﻤﺖ ﺭﺍﺳﺖ ﺭﺳﻴﺪ‪ .‬ﺑﻪ ﻗﺴﻤﺘﻲ ﻛﻪ ﻫﻴﭽﮕﺎﻩ ﺯﻳﺮ ﻗﻄﺮ ﻗﺮﺍﺭ ﻧﮕﻴﺮﻳﻢ ﻭ ﻓﻘﻂ ‪ +90‬ﺩﺭﺟﻪ ﻳﺎ ‪ 0‬ﺩﺭﺟﻪ ﺣﺮﮐـﺖ ﮐﻨـﻴﻢ)ﺷـﮑﻞ‬
‫ﺳﻤﺖ ﭼﭗ( ﻳﺎ ﻫﻴﭽﮕﺎﻩ ﺯﻳﺮ ﭘﺎﺭﻩ ﺧﻂ ﻭﺍﺻﻞ ﺑﻴﻦ ‪ A‬ﻭ ‪ B‬ﻗﺮﺍﺭ ﻧﮕﻴﺮﻳﻢ ﻭ ﻓﻘﻂ ‪ +45‬ﻳﺎ ‪ -45‬ﺩﺭﺟﻪ ﺣﺮﮐﺖ ﮐﻨﻴﻢ )ﺷﮑﻞ‬
‫ﺳﻤﺖ ﺭﺍﺳﺖ(؟‬

‫‪n‬‬
‫‪B‬‬

‫‪n‬‬
‫≡‬ ‫‪A‬‬ ‫‪B‬‬

‫‪A‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺩﺭ ﺷﻜﻞ ﺯﻳﺮ ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ﺍﺯ ﺭﺃﺱ ‪ A‬ﺑﻪ ‪ B‬ﺭﺳﻴﺪ؟‬
‫)ﺑﻪ ﻗﺴﻤﺘﻲ ﻛﻪ ﺣﺮﻛﺖ ﻓﻘﻂ ‪ +45‬ﻭ ﻳﺎ ‪ -45‬ﺩﺭﺟﻪ ﺑﺎﺷﺪ‪(.‬‬

‫‪A‬‬ ‫‪B‬‬
 ‫‪٥٧‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻣﻼﺣﻈﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ﺑﺎﺯ ﺑﺮﺍﯼ ‪ n=3‬ﺑﻪ ‪ ۵‬ﻃﺮﻳﻖ ﺍﻣﮑﺎﻥ ﭘﺬﻳﺮ ﺍﺳﺖ‪.‬‬

‫‪ -٦‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ‪ n‬ﺳﻜﻪ ﺭﺍ ﺩﺭ ﻗﺎﻋﺪﻩ ﻗﺮﺍﺭ ﺩﺍﺩ ﻭ ﺭﻭﻱ ﺁﻥ ﺗﻌﺪﺍﺩ ﺩﻟﺨﻮﺍﻩ ﺳﻜﻪ ﭼﻴﺪ؟‬
‫ﻣﺜﺎﻝ‪ :‬ﺑﻪ ﭼﻨﺪ ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ‪ ٣‬ﺳﻜﻪ ﺭﺍ ﺩﺭ ﻗﺎﻋﺪﻩ ﻗﺮﺍﺭ ﺩﺍﺩ ﻭ ﺭﻭﻱ ﺁﻥ ﺳﻜﻪ ﭼﻴﺪ؟‬

‫ﻣﻼﺣﻈﻪ ﻣﻴﺸﻮﺩ ﮐﻪ ﺑﺎﺯ ﺑﺮﺍﯼ ‪ n=3‬ﺑﻪ ‪ ۵‬ﻃﺮﻳﻖ ﺍﻣﮑﺎﻥ ﭘﺬﻳﺮ ﺍﺳﺖ‪.‬‬

‫‪ -٧‬ﺍﮔﺮ ﭘﻴﻤﺎﻳﺶ ‪ preorder‬ﺩﺭﺧﺖ ﺩﻭﺩﻭﻳﻲ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ 1,2,3,...,n‬ﺑﺎﺷﺪ ﭼﻨﺪ ‪ inorder‬ﺑﺮﺍﯼ ﺁﻥ ﻣﺘﺼﻮﺭ ﺍﺳﺖ؟‬

‫‪١‬‬ ‫‪١‬‬ ‫‪١‬‬

‫‪١‬‬ ‫‪١‬‬
‫‪٢‬‬
‫‪٢‬‬ ‫‪٢‬‬ ‫‪٢‬‬
‫‪٣‬‬ ‫‪٣‬‬
‫‪٣‬‬ ‫‪٢‬‬
‫‪٣‬‬ ‫‪٣‬‬

‫ﻓﻘﻂ ﺩﺭﺧﺘﻬﺎﯼ ﺑﺎﻻ ﺍﺳﺖ ﮐﻪ ﭘﻴﻤﺎﻳﺶ ‪ preorder‬ﺁﻧﻬﺎ ‪ 1,2,3‬ﺍﺳﺖ ﻭ ﻟﺬﺍ ‪ ۵‬ﻃﺮﻳﻖ ‪ inorder‬ﺯﻳﺮ ﺍﻣﮑﺎﻥ ﭘﺬﻳﺮ ﺍﺳﺖ‪:‬‬
‫‪1,2,3‬‬
‫‪1,3,2‬‬
‫‪2,1,3‬‬
‫‪2,3,1‬‬
 ‫‪٥٨‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪3,2,1‬‬
‫ﻗﺎﺑﻞ ﺍﺛﺒﺎﺕ ﺍﺳﺖ ﮐﻪ ﺟﻮﺍﺏ ﻫﻤﮕﯽ ﺍﻳﻦ ﻣﺴﺎﺋﻞ ﻫﻤﮕﯽ ﺑﺮﺍﺑﺮ ﺑﺎ ﻋﺪﺩ ﻣﻌﺮﻭﻓﯽ ﺑﻪ ﻧﺎﻡ ﻋﺪﺩ ﮐﺎﺗﺎﻻﻥ ﻣﻴﺒﺎﺷﺪ ﮐﻪ ﺩﺍﺭﺍﯼ ﻣﻘﺪﺍﺭ‬
‫ﺯﻳﺮ ﺍﺳﺖ‪:‬‬
‫‪ 2n ‬‬
‫‪ ‬‬
‫‪Cn =  ‬‬
‫‪n‬‬
‫‪n +1‬‬
‫ﺣﺎﻝ ﻧﮑﺘﻪ ﺟﺎﻟﺐ ﺩﺭ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ﺑﺎﻳﺪ ﺑﺘﻮﺍﻥ ﺛﺎﺑﺖ ﮐﺮﺩ ﮐﻪ ﺍﻳﻦ ﻣﺴﺎﺋﻞ ﻫﻤﮕﯽ ﺫﺍﺗﺎﹰ ﻳﮏ ﻣﺴﺌﻠﻪ ﻫﺴـﺘﻨﺪ ﻭ ﺩﺭ ﻧﺘﻴﺠـﻪ ﺑﺎﻳـﺪ‬
‫ﺑﺘﻮﺍﻥ ﻳﮏ ﻧﮕﺎﺷﺖ ﻳﮏ ﺑﻪ ﻳﮏ ﺑﻴﻦ ﺟﻮﺍﺑﻬﺎﯼ ﺁﻧﻬﺎ ﺍﻳﺠﺎﺩ ﮐﺮﺩ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺑﻪ ﺑﺮﺭﺳﻲ ﺭﺍﺑﻄﻪﻫﺎﻱ ﺑﻴﻦ ﺍﻳﻦ ﻣﺴﺌﻠﻪﻫﺎ ﻣﻲﭘﺮﺩﺍﺯﻳﻢ)ﺳﻌﯽ ﮐﻨﻴﺪ ﺍﻳﻦ ﺭﻭﺍﺑﻂ ﺭﺍ ﺍﺯ ﺭﻭﯼ ﺷﮑﻞ ﺑﻴﺎﺑﻴﺪ(‪.‬‬
‫ﺭﺍﺑﻄﻪﺍﻱ ﺑﻴﻦ ﻣﺴﺌﻠﻪ ‪ ١‬ﻭ ‪٢‬‬

‫*‬

‫‪M1‬‬ ‫*‬
‫‪M2‬‬ ‫*‬

‫‪M3‬‬ ‫‪M4‬‬

‫*‬
‫*‬
‫‪M1‬‬ ‫*‬ ‫*‬
‫‪M4‬‬
‫*‬
‫‪M4‬‬ ‫‪M1‬‬
‫*‬

‫‪M2‬‬
‫‪M3‬‬ ‫‪M2‬‬
‫‪M3‬‬
‫*‬ ‫*‬

‫‪M4‬‬ ‫*‬ ‫*‬

‫*‬

‫*‬ ‫‪M3‬‬ ‫‪M1‬‬ ‫‪M2‬‬ ‫‪M3‬‬ ‫‪M4‬‬

‫‪M1‬‬ ‫‪M2‬‬
‫‪٥٩‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﺭﺍﺑﻄﻪ ﺑﻴﻦ ﻣﺴﺌﻠﻪ ‪ ٤‬ﻭ ‪٢‬‬

‫ﺭﺍﺑﻄﻪ ﺑﻴﻦ ﻣﺴﺌﻠﻪ ‪٥‬ﻭ‪:٦‬‬

‫ﺳﻌﯽ ﮐﻨﻴﺪ ﺭﺍﺑﻄﻪ ﺑﻴﻦ ﺑﻘﻴﻪ ﻣﺴﺎﺋﻞ ﺭﺍ ﺧﻮﺩﺗﺎﻥ ﺑﺪﺳﺖ ﺁﻭﺭﻳﺪ‪.‬‬

‫ﻪ‬ ‫ﺍ‬ ‫‪۴‬‬

‫‪۵‬‬

‫ﺎ‬ ‫ﻫ‬ ‫ﺲ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺗ‬ ‫ﺎ‬ ‫ﻣ‬ ‫ﻬ‬ ‫ﺑ‬ ‫ﻭ‬ ‫ﻱ‬ ‫ﻩ‬ ‫ﺮ‬ ‫ﺠ‬ ‫ﻧ‬ ‫ﺯ‬ ‫ﺏ‬ ‫ﺮ‬ ‫ﺿ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻨ‬ ‫ﻴ‬ ‫ﻴ‬

‫ﻣﻴﺪﺍﻧﻴﻢ ﮐﻪ ﺩﺭ ﺿﺮﺏ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ﮐﻪ ﺍﻭﻟﯽ ﺩﺍﺭﺍﯼ ‪ m‬ﺳﻄﺮ ﻭ ‪ n‬ﺳﺘﻮﻥ ﻭ ﺩﻭﻣﯽ ﺩﺍﺭﺍﯼ ‪ n‬ﺳﻄﺮ ﻭ ‪ p‬ﺳﺘﻮﻥ ﺍﺳﺖ ﺑﺎﻳﺪ ﺑـﻪ‬
‫ﺗﻌﺪﺍﺩ ‪ m*n*p‬ﺿﺮﺏ ﺍﻧﺠﺎﻡ ﺩﺍﺩ ﻭﻟﺬﺍ ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﻫﺰﻳﻨﻪ ﺿـﺮﺏ ﺍﻳـﻦ ﺩﻭ ﻣـﺎﺗﺮﻳﺲ ﺭﺍ ﺑﺮﺍﺑـﺮ ﺑـﺎ ‪ m*n*p‬ﺩﺭ ﻧﻈـﺮ‬
‫ﻣﻴﮕﻴﺮﻳﻢ‪ .‬ﺑﺎ ﺍﻳﻦ ﻓﺮﺽ ﺑﻪ ﺷﺮﺡ ﺻﻮﺭﺕ ﻣﺴﺌﻠﻪ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪ .‬ﺩﺭ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ‪ n‬ﻣﺎﺗﺮﻳﺲ ﺑﺎﻳﺪ ﺩﺭ ﻫـﻢ‬
‫ﺿﺮﺏ ﺷﻮﻧﺪ ﻭ ﻫﺪﻑ ﺗﻌﻴﻴﻦ ﻃﺮﻳﻘﯽ ﺍﺯ ﺿﺮﺏ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﺁﻥ ﻫﺰﻳﻨﻪ ﮐﻤﻴﻨﻪ ﮔﺮﺩﺩ)ﻣﻴـﺪﺍﻧﻴﻢ ﮐـﻪ ﺗﻌـﺪﺍﺩ ﻃـﺮﻕ ﺿـﺮﺏ ‪n‬‬
‫ﻣﺎﺗﺮﻳﺲ ﺑﺮﺍﺑﺮ ﺑﺎ ‪ Cn-1‬ﺍﺳﺖ(‪.‬‬
‫‪٦٠‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪p0,p1, …,pn‬‬ ‫ﺍﻋﺪﺍﺩ ﺻﺤﻴﺢ‬ ‫ﻭﺭﻭﺩﻱ‪:‬‬

‫ﻛﻪ ﺩﺭ ﺁﻥ ﻣﺎﺗﺮﻳﺲ ‪ pi-1‬ﺗﻌﺪﺍﺩ ﺳﻄﺮﻫﺎ ﻭ ‪ pi‬ﺗﻌﺪﺍﺩ ﺳﺘﻮﻧﻬﺎ ﻣﺎﺗﺮﻳﺲ ‪ i‬ﺍﻡ )‪ (Mi‬ﺍﺳﺖ‪.‬‬
‫ﺧﺮﻭﺟﻲ‪ :‬ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺿﺮﺏ ﻣﺎﺗﺮﻳﺲﻫﺎﯼ ‪ M1‬ﺗﺎ ‪Mn‬‬
‫‪m1 ∗ m2 ∗ m3 ∗ ...... ∗ mn‬‬
‫ﺭﻭﺵ ﺣﻞ‪:‬‬
‫‪cos t (m pi× pj ∗ m pj× pk ) = p i ∗ p j ∗ p k‬‬
‫ﻣﺮﺍﺣﻞ ﺑﺮﻧﺎﻣﻪﺳﺎﺯﻱ ﭘﻮﻳﺎ‪:‬‬

‫‪ -۱‬ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺿﺮﺏ ﻣﺎﺗﺮﻳﺲﻫﺎﯼ ‪m[i, j ] = M *...*M‬‬

‫‪i‬‬ ‫‪j‬‬

‫‪m[i,i]=0 -۲‬‬
‫‪ -۳‬ﺟﻮﺍﺏ =]‪m[1,n‬‬
‫‪m[i, j ] = min i≤k < j {m[i, k ] + m[k + 1, j ] + pi −1 p k p j } -۴‬‬
‫ﺗﻮﺿﻴﺢ‪:‬‬
‫ﺑﺎ ﮐﻤﯽ ﺩﻗﺖ ﺩﺭ ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﻧﺤﻮﻩ ﻣﺤﺎﺳﺒﻪ ﻋﻨﺎﺻﺮ ﻣﺎﺗﺮﻳﺲ ‪ m‬ﺩﺳﺖ ﻳﺎﻓﺖ‪ .‬ﻫﻤﭽﻨـﻴﻦ ﭼـﻮﻥ ﻫﻤﻴﺸـﻪ ﺩﺭ‬
‫]‪ m[i,j‬ﻓﺮﺽ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﮐﻪ ‪ i≤j‬ﻟﺬﺍ ﻓﻘﻂ ﻋﻨﺎﺻﺮ ﺑﺎﻻﯼ ﻗﻄﺮ ﺍﺻﻠﯽ ﺩﺭ ﻣﺎﺗﺮﻳﺲ ‪ m‬ﺑﺎﻳﺪ ﻣﺤﺎﺳﺒﻪ ﺷﻮﻧﺪ‪.‬‬

‫‪m 1 2‬‬ ‫‪j‬‬ ‫‪n‬‬

‫‪1‬‬ ‫‪0‬‬ ‫ﺟﻮﺍﺏ‬

‫‪2‬‬ ‫‪× 0‬‬

‫‪× × 0‬‬
‫‪i‬‬ ‫‪× × × 0‬‬
‫‪× × × × 0‬‬
‫‪n‬‬ ‫‪× × × × × 0‬‬

‫‬ ‫‬ ‫‬ ‫‬ ‫‬

‫‪٦١‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻭﺍﺿﺢ ﺍﺳﺖ ﮐﻪ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﻣﺎﺗﺮﻳﺲ ‪ m‬ﺑﺎﻳﺪ ﻋﻨﺎﺻﺮ ﺑﺎﻻﯼ ﻗﻄﺮ ﺍﺻﻠﯽ ﻣﺤﺎﺳﺒﻪ ﺷﻮﻧﺪ ﻭ ﺑﺮﺍﯼ ﻫﺮ ﺩﺭﺍﻳﻪ ﻧﻴﺰ ﺩﺭ ﺑﺪﺗﺮﻳﻦ‬
‫ﻭﺿﻌﻴﺖ ﻧﻴﺎﺯ ﺑﻪ ﻣﻴﻨﻴﻤﻢ ﮔﻴﺮﯼ ﺭﻭﯼ ‪ n-1‬ﻋﻀﻮ ﻭﺟﻮﺩ ﺩﺍﺭﺩ)ﺑﺮ ﺍﺳﺎﺱ ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ ﺩﺭ ﺍﻟﮕـﻮﺭﻳﺘﻢ( ﻭ ﺍﺯ ﺍﻳـﻦ ﺭﻭ ﺍﻳـﻦ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﺍﺭﺍﯼ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ )‪ O(n3‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫ﻣﺤﺎﺳﺒﻪ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺿﺮﺏ‪ ٤‬ﻣﺎﺗﺮﻳﺲ ‪) :‬ﺑﻪ ‪ ٥‬ﻃﺮﻳﻖ ﻣﻲﺗﻮﺍﻥ ‪ ٤‬ﻣﺎﺗﺮﻳﺲ ﺭﺍ ﺿﺮﺏ ﻛﺮﺩ‪(.‬‬
‫ﻭﺭﻭﺩﯼ‪:‬‬
‫)‪M1(2*3)*M2(3*5)*M3(5*4)*M4(4*1‬‬

‫‪p0=2 , p1=3, p2=5, p3=4, p4=1‬‬

‫‪m[1,2]=min{m[1,1]+m[2,2]+p0p1p2}=2*3*5=30‬‬
‫‪m[2,3]=min{m[2,2]+m[3,3]+p1p2p3}=3*5*4=60‬‬
‫}‪m[1,3]=min{m[1,1]+m[2,3]+p0p1p3 , m[1,2]+m[3,3]+p0p2p3‬‬
‫‪=min{60+2*3*4,30+2*5*4}=70‬‬
‫‪m[3,4]=min{m[3,3]+m[4,4]+p2p3p4 }=20‬‬
‫}‪m[2,4]=min{m[2,2]+m[3,4]+p1p2p4 , m[2,3]+m[4,4]+p1p3p4‬‬
‫‪=min{20+3*5*1,60+3*4*1}=35‬‬
‫‪m[1,4]=min{m[1,1]+m[2,4]+p0p1p4 , m[1,2]+m[3,4]+p0p2p4, m[1,3]+ m[4,4] +‬‬
‫} ‪p0p3p4‬‬
‫‪=min{35+2*3*1, 30+20+2*5*1,70+2*4*1}=41‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺑﺮﺍﯼ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻥ ﻃﺮﻳﻖ ﺑﻬﻴﻨﻪ ﺿﺮﺏ ﺑﺎﻳﺪ ﺩﻗﺖ ﮐﺮﺩ ﮐﻪ ﺟﻮﺍﺏ ﺑﻬﻴﻨﻪ ﺑـﺮ ﺍﺳـﺎﺱ ﮐـﺪﺍﻡ ﺍﻧﺘﺨـﺎﺏ ﺑﺪﺳـﺖ ﺁﻣـﺪﻩ‬
‫ﺍﺳﺖ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺟﻮﺍﺏ ‪ ۴۱‬ﺩﺭ ﻣﺜﺎﻝ ﺑﺎﻻ ﺑﻪ ﺧﺎﻃﺮ ﮐﻤﻴﻨﻪ ﺑﻮﺩﻥ ‪ 35+2*3*1‬ﺑﺪﺳﺖ ﺁﻣﺪﻩ ﺍﺳـﺖ ﮐـﻪ ﺍﻳـﻦ ﻣﻘـﺪﺍﺭ ﻧﻴـﺰ‬
‫ﻫﻤﺎﻥ ‪ m[1,1]+m[2,4]+p0p1p4‬ﺍﺳﺖ ﻭ ﻟﺬﺍ ﺑﺎﻳﺪ ﺍﺑﺘﺪﺍ ‪ M1‬ﺭﺍ ﺟﺪﺍ ﮐﺮﺩ ﻭ ﺟﻮﺍﺏ ﺑﻬﻴﻨـﻪ ‪ M2*...*M4‬ﺭﺍ ﺑﺪﺳـﺖ‬
‫ﺁﻭﺭﺩ ﻭ ﺍﻳﻦ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ﺭﺍ ﺩﺭ ﻫﻢ ﺿﺮﺏ ﮐﺮﺩ‪ m[2,4] .‬ﻧﻴﺰ ﺧﻮﺩ ﺍﺯ ﺭﻭﯼ ‪ m[2,2]+m[3,4]+p1p2p4‬ﻣﺤﺎﺳﺒﻪ ﺷﺪﻩ‬
‫ﺍﺳﺖ ﻭ ﻟﺬﺍ ﺑﺎﻳﺪ ﺍﺑﺘﺪﺍ ﺟﻮﺍﺏ ﺑﻬﻴﻨﻪ ‪ M3*M4‬ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻩ ﻭ ﺩﺭ ‪ M2‬ﺿﺮﺏ ﮐﺮﺩ‪ .‬ﭘﺲ ﻃﺮﻳﻘﻪ ﺿﺮﺏ ﺑﻬﻴﻨﻪ ﺑﺼـﻮﺭﺕ‬
‫ﺯﻳﺮ ﺍﺳﺖ‪:‬‬
‫) ) )‪(M1) * ( (M2) * ( (M3) * (M4‬‬

‫ﻪ‬

‫‪٥‬‬ ‫‪٥‬‬

‫ﺏ‬ ‫ﻣ‬ ‫ﻌ‬ ‫ﺿ‬ ‫ﻬ‬ ‫ﺑ‬ ‫ﯼ‬ ‫ﺑ‬ ‫ﺚ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺪ‬ ‫ﺤ‬ ‫ﯽ‬ ‫ﻠ‬ ‫ﺪ‬ ‫ﻨ‬ ‫ﭼ‬ ‫ﻨ‬ ‫ﻴ‬ ‫ﺪ‬ ‫ﻨ‬ ‫ﻠ‬ ‫ﺜ‬

‫ﻳﮑﯽ ﺩﻳﮕﺮ ﺍﺯ ﻣﺴﺌﻠﻪ ﻫﺎﻱ ﺟﺎﻟﺒﯽ ﮐﻪ ﺗﻮﺳﻂ ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﻣﻴﺘﻮﺍﻥ ﺑﺮﺍﯼ ﺁﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮐﺎﺭﺍﻳﻲ ﺗﻮﻟﻴﺪ ﮐﺮﺩ ﻣﺴـﺌﻠﻪ‬
‫ﻣﺜﻠﺚ ﺑﻨﺪﯼ )‪ (triangulation‬ﺑﻬﻴﻨﻪ ﻳﮏ ﭼﻨﺪ ﺿﻠﻌﯽ ﻣﺤﺪﺏ ﻧﺎﻡ ﺩﺍﺭﺩ‪ .‬ﺍﮐﻨﻮﻥ ﺑﻪ ﺑﻴـﺎﻥ ﺍﻳـﻦ ﻣﺴـﺌﻠﻪ ﻭ ﺭﻭﺵ ﺣـﻞ ﺁﻥ‬
‫ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬
‫ﻭﺭﻭﺩﯼ‪ :‬ﻣﺨﺘﺼﺎﺕ ‪ n+1‬ﺭﺍﺱ ﺍﺯ ﻳﮏ ‪ n+1‬ﺿﻠﻌﯽ ﻣﺤﺪﺏ ﮐﻪ ﺭﺋﻮﺱ ﺁﻥ ﺑﺼﻮﺭﺕ ‪ V0, V1, ..., Vn‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻫﺪﻑ ‪ :‬ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﭼﻨﺪ ﺿﻠﻌﯽ ﺑﻪ ﮔﻮﻧﻪ ﺍﯼ ﮐﻪ ﻣﺠﻤﻮﻉ ﻣﺤﻴﻂ ﻣﺜﻠﺜﻬﺎ ﮐﻤﻴﻨﻪ ﮔﺮﺩﺩ‪.‬‬
‫‪٦٢‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻗﺒﻞ ﺍﺯ ﺍﺭﺍﺋﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺍﺑﺘﺪﺍ )‪ W(i,j,k‬ﺭﺍ ﺑﺼﻮﺭﺕ ﻫﺰﻳﻨﻪ ﻣﺜﻠﺚ ‪ Vi,Vj,Vk‬ﻳﺎ ﻫﻤﺎﻥ ﻣﺤﻴﻂ ﻣﺜﻠـﺚ ‪ Vi,Vj,Vk‬ﺗﻌﺮﻳـﻒ‬
‫ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ‪:‬‬
‫ﺷﺒﻴﻪ ﺩﻳﮕﺮ ﻣﺴﺎﺋﻞ ﺑﺎﻳﺪ ﺑﻪ ﺍﺭﺍﺋﻪ ‪ ۴‬ﻣﺮﺣﻠﻪ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﺑﭙﺮﺩﺍﺯﻳﻢ‪:‬‬
‫‪ -۱‬ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﺭﻭﯼ ﺭﺋﻮﺱ ‪t[i,j] =Vi-1, Vi, ..., Vj‬‬
‫‪) t[i,i+1]=0 -۲‬ﺑﺪﻳﻬﯽ(‬
‫‪ -۳‬ﺟﻮﺍﺏ = ]‪t[1,n‬‬
‫‪ -۴‬ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ‪:‬‬

‫{‬
‫) ‪t [ i , j ] = min t [i , k ] + t [ k + 1, j ] + w (v i −1 ,v k ,v j‬‬ ‫}‬
‫‪i ≤k < j‬‬

‫‪Vj‬‬

‫‪Vi-1‬‬
‫‪24@Q& IC 2& E"# M"4& R/S‬‬

‫‪Vi‬‬

‫‪24@Q& IC 2& E"# M"4& R/S‬‬ ‫‪Vk‬‬

‫ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ ﺑﺪﻳﻦ ﺻﻮﺭﺕ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺍﺳﺖ ﮐﻪ ﺩﺭ ﻃﺮﻳﻘﻪ ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﺑﻬﻴﻨﻪ ﺭﺋـﻮﺱ ‪ Vi-1‬ﺗـﺎ ‪ Vj‬ﺭﺍﺳـﯽ ﻣﺜـﻞ ‪Vk‬‬
‫ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﻫﻢ ﺍﺯ ‪ Vi-1‬ﻭ ﻫﻢ ﺍﺯ ‪ Vj‬ﺑﻪ ﺁﻥ ﻗﻄـﺮﯼ ﻣﺘﺼـﻞ ﮔﺮﺩﻳـﺪﻩ ﺍﺳـﺖ ﻭ ﻫﻤﭽﻨـﻴﻦ ‪ Vi-1‬ﺗـﺎ ‪ Vk‬ﻭ ‪ Vk‬ﺗـﺎ ‪Vj‬‬
‫ﺑﺼﻮﺭﺕ ﺑﻬﻴﻨﻪ ﻣﺜﻠﺚ ﺑﻨﺪﯼ ﺷﺪﻩ ﺍﻧﺪ‪ .‬ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺮﺍﯼ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﭼﻨﻴﻦ ‪ k‬ﺍﯼ ﺑﺎﻳﺪ ﺗﻤﺎﻡ ﺭﺋﻮﺱ ﺑﻴﻦ ‪ Vi-1‬ﺗﺎ ‪ Vj‬ﺭﺍ ﺑﺮﺭﺳـﯽ‬
‫ﮐﺮﺩ‪.‬‬

‫ﻣﺜﺎﻝ‪ :‬ﭼﻨﺪ ﺿﻠﻌﻲ ﺯﻳﺮ ﺭﺍ ﺑﻪ ﺭﻭﺵ ﺑﺎﻻ ﺑﺎ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﻣﺜﻠﺚﺑﻨﺪﻱ ﻛﻨﻴﺪ؟‬
‫‪t [1,2] = min{t (1,1) + t (2,2 ) + v0 v1v 2 } = 1 + 2 + 5‬‬
‫{‬
‫‪t [1,3] = min t (1,2 ) + t (2,3) + v 0 v 2 v3 = 3 + 2 + 3 5‬‬ ‫‪2‬‬ ‫‬ ‫‪2‬‬

‫‪t (1,2 ) + t (3,3) + v0 v 2 v3 = 2 + 2 + 3 5‬‬ ‫}‬ ‫
‬

‫‪5‬‬
‫‬
‫‪= 2+ 2 +3 5‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪t [2,3] = min{t (2,2 ) + t (3,3) + v1v 2 v3 } = 3 + 5‬‬
‫‪5‬‬

‫‬ ‫‬
‫‪t [3,4] = min{t (3,3) + t (4,4 ) + v 2 v3 v 4 } = 3 5‬‬ ‫‪2‬‬
‫‪t [2,4] = min{t (2,2 ) + t (3,4 ) + v1v 2 v3 = 6 + 2 5‬‬
‫‪t (2,3) + t (4,4 ) + v1v3 v 4 = 6 + 2 5‬‬ ‫}‬
‫‪٦٣‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪t [1,4] = min{t (1,1) + t (2,4 ) + v0 v1v 4 = 8 + 2 2 + 2 5‬‬ ‫و‬

‫‪t (1,2 ) + t (3,4 ) + v0 v 2 v 4 = 4 + 4 5 + 2 2‬‬ ‫و‬
‫‪t (1,3) + t (4,4 ) + v0 v3 v 4‬‬ ‫‪}= 4 + 2‬‬ ‫‪2 +4 5‬‬

‫)‪(LCS‬‬
‫ﮎ‬
‫ﻪ‬
‫‪٦‬‬

‫‪٥‬‬

‫ﺮ‬ ‫ﺘ‬ ‫ﺸ‬ ‫ﻣ‬ ‫ﻟ‬ ‫ﺎ‬ ‫ﻧ‬ ‫ﺩ‬ ‫ﺮ‬ ‫ﻳ‬ ‫ﺯ‬ ‫ﻦ‬ ‫ﻳ‬ ‫ﺮ‬ ‫ﺗ‬ ‫ﻧ‬ ‫ﻻ‬ ‫ﻮ‬ ‫ﻃ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺒ‬ ‫ﻲ‬

‫ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﻣﺴﺌﻠﻪ ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳـﺮ ﺩﻧﺒﺎﻟـﻪ ﻣﺸـﺘﺮﮎ )‪ (Longest Common Subsequence‬ﻣﻴﭙـﺮﺩﺍﺯﻳﻢ‪.‬‬
‫ﺍﺑﺘﺪﺍ ﺗﻌﺮﻳﻔﻬﺎﯼ ﻻﺯﻡ ﺭﺍ ﺍﺭﺍﺋﻪ ﻣﻴﺪﻫﻴﻢ‪.‬‬
‫ﺭﺷﺘﻪ‪ :‬ﺩﻧﺒﺎﻟﻪ ﺍﯼ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﻱ ﭘﺸﺖﺳﺮﻫﻢ ﺑﺎ ﺗﺮﺗﻴﺒﯽ ﺧﺎﺹ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺩﺭ ﺯﻳﺮ ﺭﺷـﺘﻪ ‪ X‬ﮐـﻪ ﺩﻧﺒﺎﻟـﻪ ﺍﯼ ﺍﺯ ‪ m‬ﺣـﺮﻑ‬
‫ﺍﺳﺖ ﺩﻳﺪﻩ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﭘﻴﺸﻮﻧﺪ ‪ i‬ﺍﻡ ‪ i :X‬ﺣﺮﻑ ﭘﺸﺖ ﺳﺮ ﻫﻢ ﺍﺯ ﺍﺑﺘﺪﺍﯼ ﺭﺷﺘﻪ ‪ X‬ﺭﺍ ﭘﻴﺸﻮﻧﺪ ‪ i‬ﺍﻡ ‪ X‬ﮔﻮﻳﻨﺪ ﻭ ﺑﺎ ‪ Xi‬ﻧﺸﺎﻥ ﻣﻴﺪﻫﻨﺪ‪.‬‬
‫ﺣﺮﻑ ‪ i‬ﺍﻡ‪ h :‬ﺍﻣﻴﻦ ﺣﺮﻑ ﺭﺷﺘﻪ ‪ X‬ﺭﺍ ﺑﺎ ‪ xi‬ﻧﺸﺎﻥ ﻣﻴﺪﻫﻨﺪ‪.‬‬
‫> ‪X =< x1 ,L, xm‬‬
‫> ‪X i =< x1 ,L, xi‬‬
‫> ‪Z =< z1 ,L, z k‬‬

‫ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ‪ :‬ﮔﻮﻳﻴﻢ ‪ z‬ﺯﻳﺮﺩﻧﺒﺎﻟﻪﺍﻱ ﺍﺯ ‪ X‬ﺍﺳﺖ ﺍﮔﺮ‪:‬‬

‫‪∃i1 , i2 ,L, ik | i1 < i2 < L < ik :∀ j : 1 ≤ j ≤ k z j = xi j‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫>‪X=<A,B,B,A,D,A,B,F‬‬

‫>‪Z= <B,A,A,F‬‬
‫‪i1 = 2 ⇒ z1 = x2‬‬
‫‪i = 4 ⇒ z = x‬‬
‫‪2‬‬ ‫‪2‬‬ ‫‪4‬‬
‫‪‬‬
‫‪i3 = 6 ⇒ z 3 = x6‬‬
‫‪i4 = 8 ⇒ z 4 = x8‬‬

‫ﻧﮑﺘﻪ‪ :‬ﻫﺮ ﺭﺷﺘﻪ ‪ m‬ﺣﺮﻓﯽ ﺩﺍﺭﺍﯼ ‪ 2m‬ﺯﻳﺮﺩﻧﺒﺎﻟﻪ ﺍﺳﺖ‪.‬‬

‫ﺩﺭﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺩﺭ ﻭﺭﻭﺩﻱ ﺩﻭ ﺭﺷﺘﻪ ﺑﻪ ﻃﻮﻝﻫـﺎﻱ ‪ n,m‬ﻭﺟـﻮﺩ ﺩﺍﺭﺩ‪ .‬ﻛـﻪ ﻫـﺪﻑ ﻣﺴـﺌﻠﻪ ﺑﺪﺳـﺖ ﺁﻭﺭﺩﻥ ﻃـﻮﻻﻧﻲﺗـﺮﻳﻦ‬
‫ﺯﻳﺮﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﻙ ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫ﻭﺭﻭﺩﯼ‪:‬‬
‫ﺩﻭ ﺩﻧﺒﺎﻟﻪ ‪ X‬ﻭ ‪ Y‬ﮐﻪ ﺍﻭﻟﯽ ﺑﻪ ﻃﻮﻝ ‪ m‬ﻭ ﺩﻭﻣﯽ ﺑﻪ ﻃﻮﻝ ‪ n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﺧﺮﻭﺟﯽ‪ :‬ﻃﻮﻝ ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﮎ ‪ X‬ﻭ ‪Y‬‬
‫‪٦٤‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﻳﻚ ﺭﺍﻩﺣﻞ ﺳﺎﺩﻩ ﺟﻬﺖ ﺣﻞ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑﻊ ﺯﻳﺮ ﻭ ﻳﻚ ﺁﺭﺍﻳﻪ ﺩﻭﺑﻌﺪﻱ ‪ m × n‬ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫ﺷﺒﻴﻪ ﺩﻳﮕﺮ ﻣﺴﺎﺋﻞ ﺑﺎﻳﺪ ﺑﻪ ﺍﺭﺍﺋﻪ ‪ ۴‬ﻣﺮﺣﻠﻪ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﺑﭙﺮﺩﺍﺯﻳﻢ‪:‬‬
‫‪ -۱‬ﻃﻮﻝ ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﮎ ‪ Xi‬ﻭ ‪c[i,j] = Yj‬‬
‫‪) c[i,0]=c[0,j]=0 ; ∀i,j -۲‬ﺑﺪﻳﻬﯽ() ﻭﻗﺘﻲ ﻳﻜﻲ ﺍﺯ ﺭﺷﺘﻪﻫﺎ ﺗﻬـﻲ ﺑﺎﺷـﺪ ﻫـﻴﭻ ﺍﺷـﺘﺮﺍﻛﻲ ﻭﺟـﻮﺩ ﻧﺨﻮﺍﻫـﺪ‬
‫ﺩﺍﺷﺖ(‬
‫‪ -۳‬ﺟﻮﺍﺏ = ]‪c[m,n‬‬
‫‪ -۴‬ﺭﺍﺑﻄﻪ ﺑﺎﺯﮔﺸﺘﯽ‪:‬‬
‫‪‬‬ ‫‪c[i − 1, j − 1] + 1‬‬ ‫‪; xi = y j‬‬
‫‪c[i, j ] = ‬‬
‫‪max{c[i − 1, j ], c[i, j − 1]} ; else‬‬

‫ﺑﻪ ﺭﺍﺣﺘﯽ ﻣﻴﺘﻮﺍﻥ ﺑﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻳﮏ ﻣﺎﺗﺮﻳﺲ )‪ (m+1)*(n+1‬ﺑﻪ ﺟﺎﯼ ‪ c‬ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺎﻻ ﺭﺍ ﭘﻴﺎﺩﻩ ﺳﺎﺯﯼ ﻧﻤﻮﺩ‪.‬‬

‫‪c‬‬ ‫‪0 1‬‬ ‫‪j‬‬ ‫‪n‬‬

‫‪0‬‬ ‫‪0 0 0‬‬ ‫‪0‬‬ ‫‪0 0‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪ci-1,j-1 ci-1,j‬‬
‫‪i‬‬ ‫‪0‬‬ ‫‪ci,j-1‬‬ ‫‪ci,j‬‬
‫‪0‬‬
‫‪m 0‬‬ ‫ﺟﻮﺍﺏ‬

‫ﺭﻭﺵ ﻣﺤﺎﺳﺒﻪ‪ :‬ﭼﻮﻥ ‪ ci,j‬ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﻧﻴﺎﺯ ﺑﻪ ‪ ci-1,j-1‬ﻭ ‪ ci,j-1‬ﻭ ‪ ci-1,j‬ﺩﺍﺭﺩ ﻟﺬﺍ ﺭﻭﺵ ﻣﺤﺎﺳـﺒﻪ ﺑﺼـﻮﺭﺕ ﺯﻳـﺮ ﻗﺎﺑـﻞ‬
‫ﺍﺟﺮﺍ ﻣﻴﺒﺎﺷﺪ‪:‬‬

‫‬ ‫‬ ‫‬ ‫‬ ‫‬

٦٥ (Dynamic Programming)

   ‫ز‬   
 ‫ش‬ ‫و‬ ‫ر‬

:‫ﺩﺭ ﺯﻳﺮ ﺷﺒﻪ ﮐﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺩﻳﺪﻩ ﻣﻴﺸﻮﺩ‬

Procedure LCS (X,Y,m,n)
For i0 to m do c[i,0]
0 repeat
For j0 to n do c[0,j]
0 repeat
For i1 to m do
For j1 to n do
If xi=yj then c[i,j]  1+c[i-1,j-1] , b[i,j]
''
elsif c[i-1,j] > c[i,j-1] then c[i,j]  c[i-1,j] , b[i,j]
''
else c[i,j]  c[i,j-1] , b[i,j]
''
endif
repeat
repeat
end.
.‫ ﻣﻴﺒﺎﺷﺪ‬O(m.n) ‫ﻭﺍﺿﺢ ﺍﺳﺖ ﮐﻪ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
:‫ﺣﺎﻝ ﺭﻭﻳﻪ ﺍﯼ ﺑﺎﺯﮔﺸﺘﯽ ﺭﺍ ﻣﻴﺒﻴﻨﻴﻢ ﮐﻪ ﺗﻮﺳﻂ ﺁﻥ ﻣﻴﺘﻮﺍﻥ ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳﺮ ﺭﺷﺘﻪ ﻣﺸﺘﺮﮎ ﺭﺍ ﭼﺎﭖ ﮐﺮﺩ‬
procedure print_LCS(X,b,i,j)
if (i=0) or (j=0) then return endif
if b[i,j] = '' then
print_LCS(X,b, i-1, j-1)
write (xi)
elsif b[i,j] = '' then
print_LCS(X,b,i,j-1)
else
print_LCS(X,b, i-1,j)
endif
end.

.‫ ﺑﺎﺷﺪ‬print_LCS(X,b,m,n) ‫ ﺑﺎﻳﺪ ﺑﺼﻮﺭﺕ‬print_LCS ‫ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺍﻭﻟﻴﻪ ﺭﻭﻳﻪ‬:‫ﻧﮑﺘﻪ‬

.‫ ﻣﻴﺒﺎﺷﺪ‬m+n ‫ ﻭ ﺑﻴﺸﺘﺮﻳﻦ ﺁﻧﻬﺎ ﺑﺮﺍﺑﺮ ﺑﺎ‬min (m,n) ‫ ﺑﺮﺍﺑﺮ ﺑﺎ‬print_LCS ‫ ﻛﻤﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﻓﺮﺍﺧﻮﺍﻧﻲ ﺭﻭﻳﻪ‬:‫ﻧﮑﺘﻪ‬
.‫ ﻣﻴﺒﺎﺷﺪ‬min(m,n) ‫ ﺑﺮﺍﺑﺮ ﺑﺎ ﺻﻔﺮ ﻭ ﺑﻴﺸﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ ﺁﻥ ﺑﺮﺍﺑﺮ ﺑﺎ‬print_LCS ‫ ﺩﺭ ﺭﻭﻳﻪ‬write ‫ ﻛﻤﺘﺮﻳﻦ ﺗﻌﺪﺍﺩ‬:‫ﻧﮑﺘﻪ‬

:‫ﻣﺜﺎﻝ‬
n ‫ﺑﻪ ﻃﻮﻝ‬Y ‫ ﻭ‬m ‫ ﺑﻪ ﻃﻮﻝ‬X ‫ ﺩﻭ ﺩﻧﺒﺎﻟﻪ‬:‫ﻭﺭﻭﺩﻱ‬
Y ‫ ﻭ‬X ‫ ﻃﻮﻝ ﻃﻮﻻﻧﻲﺗﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﻙ‬:‫ﺧﺮﻭﺟﻲ‬

X= <A,B,B,A,D,A,B,F>

Y= <B,F,A,F,D,H,B>
‫‪٦٦‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﺑﺎ ﺍﺟﺮﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﻪ ﻣﺎﺗﺮﻳﺲ ﺯﻳﺮ ﺧﻮﺍﻫﻴﻢ ﺭﺳﻴﺪ‪:‬‬

‫ﺟﻬﺖ ﻭﺿﻮﺡ ﺑﻴﺸﺘﺮ ﻫﺮ ﺩﻭ ﻣﺎﺗﺮﻳﺲ ‪ c‬ﻭ ‪ b‬ﺩﺭ ﻳﮏ ﻣﺎﺗﺮﻳﺲ ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﺷﺪﻩ ﺍﺳﺖ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻭﻗﺘﯽ ﻫﺮ ﺩﻭ ﺩﺭﺍﻳﻪ ]‪ c[i-1,j‬ﻭ ]‪ c[i,j-1‬ﺑﺎ ﻫﻢ ﺑﺮﺍﺑﺮ ﺑﺎﺷـﻨﺪ ﻫـﺮ ﮐـﺪﺍﻡ ﺍﺯ ﺁﻧﻬـﺎ ﺑـﻪ ﺩﻟﺨـﻮﺍﻩ ﻣﻴﺘﻮﺍﻧﻨـﺪ ﺑـﻪ ﻋﻨـﻮﺍﻥ‬
‫}]‪ max{c[i-1,j],c[i,j-1‬ﺍﻧﺘﺨﺎﺏ ﺷﻮﻧﺪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺩﺭ ﺑﺎﻻ ﺑﺼـﻮﺭﺗﯽ ﺍﺳـﺖ ﮐـﻪ ]‪ c[i,j-1‬ﺭﺍ ﺑـﻪ ﻋﻨـﻮﺍﻥ‬
‫ﺑﻴﺸﻴﻨﻪ ﺍﻧﺘﺨﺎﺏ ﻣﻴﮑﻨﺪ‪.‬‬

‫‪c,b‬‬ ‫‪-‬‬ ‫‪B‬‬ ‫‪F‬‬ ‫‪A‬‬ ‫‪F‬‬ ‫‪D‬‬ ‫‪H‬‬ ‫‪B‬‬

‫‪-‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪A‬‬ ‫‪0‬‬ ‫→‪0‬‬ ‫→‪0‬‬ ‫‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬
‫‪B‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫‪2‬‬
‫‪B‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫→‪1‬‬ ‫‪2‬‬
‫‪A‬‬ ‫‪0‬‬ ‫↓‪1‬‬ ‫→‪1‬‬ ‫‪2‬‬ ‫→‪2‬‬ ‫→‪2‬‬ ‫→‪2‬‬ ‫→‪2‬‬
‫‪D‬‬ ‫‪0‬‬ ‫↓‪1‬‬ ‫→‪1‬‬ ‫↓‪2‬‬ ‫→‪2‬‬ ‫‪3‬‬ ‫→‪3‬‬ ‫→‪3‬‬
‫‪A‬‬ ‫‪0‬‬ ‫↓‪1‬‬ ‫→‪1‬‬ ‫‪2‬‬ ‫→‪2‬‬ ‫↓‪3‬‬ ‫→‪3‬‬ ‫→‪3‬‬
‫‪B‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫→‪1‬‬ ‫↓‪2‬‬ ‫→‪2‬‬ ‫↓‪3‬‬ ‫→‪3‬‬ ‫‪4‬‬
‫‪F‬‬ ‫‪0‬‬ ‫↓‪1‬‬ ‫‪2‬‬ ‫→‪2‬‬ ‫‪3‬‬ ‫→‪3‬‬ ‫→‪3‬‬ ‫↓‪4‬‬

‫ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ print_LCS‬ﻣﺴﻴﺮ ﻣﺸﺨﺺ ﺷﺪﻩ ﺑﻪ ﺭﻧﮓ ﺧﺎﮐﺴﺘﺮﯼ ﺭﺍ ﺍﺯ ﺁﺧﺮ ﺑﻪ ﺍﻭﻝ ﻃﻲ ﮐـﺮﺩﻩ ﻭ ﺩﻭﺑـﺎﺭﻩ ﺑـﺎﺯﻣﻴﮕﺮﺩﺩ)ﺑـﻪ‬
‫ﻋﻠﺖ ﺑﺎﺯﮔﺸﺘﯽ ﺑﻮﺩﻥ ﺭﻭﻳﻪ( ﻭ ﺩﺭ ﺣﻴﻦ ﺑﺎﺯﮔﺸﺖ ﺧﺎﻧﻪ ﻫﺎﻳﻲ ﮐﻪ ﺩﺭ ﺁﻥ ﻓﻠﺶ ﻣﻮﺭﺏ ﻣﻴﺒﻴﻨﺪ ﺭﺍ ﭼـﺎﭖ ﻣﻴﮑﻨـﺪ‪ .‬ﺍﺯ ﺍﻳـﻦ ﺭﻭ‬
‫ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟﻪ ﻣﺸﺘﺮﮎ ‪ X‬ﻭ ‪ Y‬ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﭼﺎﭖ ﺧﻮﺍﻫﺪ ﺷﺪ‪:‬‬
‫>‪Z= <B,A,D,B‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺑﺪﻭﻥ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﻣﺎﺗﺮﻳﺲ ‪ b‬ﻫﻢ ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ print_LCS‬ﻣﻴﺘﻮﺍﻧﺪ ﻃﻮﻻﻧﯽ ﺗﺮﻳﻦ ﺯﻳﺮ ﺩﻧﺒﺎﻟـﻪ ﻣﺸـﺘﺮﮎ ﺭﺍ ﭼـﺎﭖ‬
‫ﮐﻨﺪ!‪.‬‬

‫‪٧‬‬

‫‪٥‬‬

‫ﺩ‬ ‫ﺮ‬ ‫ﻩ‬ ‫ﺭ‬ ‫ﻭ‬ ‫ﺩ‬ ‫ﻩ‬ ‫ﺷ‬ ‫ﻭ‬ ‫ﺮ‬ ‫ﻓ‬

‫‪-‬‬ ‫‪-‬‬

‫ﮔ‬ ‫ﺪ‬ ‫ﻨ‬

‫ﺗﻌﺮﻳﻒ‪ :‬ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ ﺩﺭ ﻳﮏ ﮔﺮﺍﻑ ﺩﻭﺭﯼ ﺍﺳﺖ ﮐﻪ ﺍﺯ ﻫﻤﻪ ﺭﺋﻮﺱ ﺩﻗﻴﻘﺎﹰ ﻳﮑﺒﺎﺭ ﺑﮕﺬﺭﺩ‪.‬‬
‫ﺩﺭ ﻣﺴﺌﻠﻪ ﻓﺮﻭﺷﻨﺪﻩ ﺩﻭﺭﻩ ﮔﺮﺩ )‪ (Traveling Salesman Problem‬ﻳﺎ ‪ ، TSP‬ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﺩﻭﺭ ﻫﻤﻴﻠﺘﻮﻧﯽ ﺑـﺎ‬
‫ﻫﺰﻳﻨﻪ ﻣﻴﻨﻴﻤﻢ ﺩﺭ ﻳﮏ ﮔﺮﺍﻑ ﻭﺯﻥ ﺩﺍﺭ ﻭﺭﻭﺩﯼ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻓﺮﺽ ﮐﻨﻴﺪ ﮔﺮﺍﻑ ﻭﺭﻭﺩﯼ ﺑﺼﻮﺭﺕ )‪ G(V,E‬ﻣﻴﺒﺎﺷﺪ ﮐﻪ ﺩﺭ ﺁﻥ }‪ V={1,2,...,n‬ﺍﺳﺖ ﻭ ‪ ci,j‬ﻧﺸﺎﻧﺪﻫﻨﺪﻩ ﻫﺰﻳﻨﻪ ﻳـﺎﻝ‬
‫)‪ (i,j‬ﺑﺎﺷﺪ‪ .‬ﻫﻤﭽﻨﻴﻦ ﺑﺪﻭﻥ ﮐﻢ ﺷﺪﻥ ﺍﺯ ﮐﻠﻴﺖ ﻣﺴﺌﻠﻪ ﻓﺮﺽ ﮐﻨﻴﺪ ﺭﺍﺱ ﺁﻏﺎﺯﻳﻦ ﺭﺍﺱ ﺷﻤﺎﺭﻩ ‪ ۱‬ﺑﺎﺷﺪ‪.‬‬
‫‪٦٧‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫ﺷﺒﻴﻪ ﺑﻘﻴﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﻳﻲ ﮐﻪ ﺑﻪ ﺭﻭﺵ ﺑﺮﻧﺎﻣﻪ ﺳﺎﺯﯼ ﭘﻮﻳﺎ ﺍﺭﺍﺋﻪ ﺷﺪ ﺑﺎﻳﺪ ‪ ۴‬ﻣﺮﺣﻠﻪ ﺭﺍ ﻃﺮﺍﺣﯽ ﮐﺮﺩ‪:‬‬
‫‪ -۱‬ﻃﻮﻝ ﮐﻮﺗﺎﻫﺘﺮﻳﻦ ﻣﺴﻴﺮﯼ ﮐﻪ ﺍﺯ ﺭﺍﺱ ‪ i‬ﺷﺮﻭﻉ ﺷﺪﻩ ﻭ ﺍﺯ ﮐﻠﻴﻪ ﺭﺋﻮﺱ ﻣﺠﻤﻮﻋـﻪ ‪ S‬ﺩﻗﻴﻘـﺎﹰ ﻳﮑﺒـﺎﺭ ﺑﮕـﺬﺭﺩ ﻭ ﺑـﻪ‬
‫ﺭﺍﺱ ‪ ۱‬ﺧﺘﻢ ﺷﻮﺩ = )‪(i∉S , 1∉S) g(i,S‬‬
‫‪) g(i, ∅)=ci,1 -۲‬ﺑﺪﻳﻬﯽ(‬
‫‪ -۳‬ﺟﻮﺍﺏ = )}‪g(1, V-{1‬‬
‫‪(j∈S, 1∉S, i∉S) g(i,S)= min{ci,j + g( j, S - {j} ) } -۴‬‬

‫ﻣﺜﺎﻝ‪ :‬ﺩﺭ ﮔﺮﺍﻑ ﺯﻳﺮ ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ ﺑﺎ ﻫﺰﻳﻨﻪ ﮐﻤﻴﻨﻪ ﺭﺍ ﭘﻴﺪﺍ ﮐﻨﻴﺪ‪:‬‬

‫‪١‬‬
‫‪١٠‬‬
‫‬
‫‪١‬‬

‫‪٩‬‬ ‫ ‪٢٠‬‬
‫‪٣‬‬ ‫‪٢‬‬
‫‪١٣‬‬
‫‪٨‬‬ ‫‪١٠‬‬
‫‪١٢‬‬ ‫‪٨‬‬
‫‪٩‬‬ ‫‪T‬‬

‫ﺩﺭ ﺍﻳﻦ ﮔﺮﺍﻑ ﻣﺎﺗﺮﻳﺲ ﻫﺰﻳﻨﻪ ﻫﺎ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻣﻴﺒﺎﺷﺪ‪:‬‬

‫‪c‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬

‫‪1‬‬ ‫‪0‬‬ ‫‪10‬‬ ‫‪15‬‬ ‫‪20‬‬
‫‪2‬‬ ‫‪5‬‬ ‫‪0‬‬ ‫‪9‬‬ ‫‪10‬‬
‫‪3‬‬ ‫‪6‬‬ ‫‪13‬‬ ‫‪0‬‬ ‫‪12‬‬
‫‪4‬‬ ‫‪8‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪0‬‬
‫‪٦٨‬‬ ‫)‪(Dynamic Programming‬‬
‫
‬ ‫‬ ‫‬ ‫‬ ‫ز‬ ‫‬ ‫‬ ‫‬ ‫ ‬ ‫
‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫‪ g (2, ∅) = c2,1 = 5‬‬

‫‪‬‬
‫‪| S |= 0 ⇒  g (3, ∅) = c3,1 = 6‬‬
‫‪ g (4, ∅) = c = 8‬‬
‫‪‬‬ ‫‪4 ,1‬‬

‫‪ g (2,{3}) = c2,3 + c3,1 = 15‬‬

‫‪‬‬
‫‪ g (2,{4}) = c2, 4 + c4,1 = 18‬‬
‫‪ g (3,{2}) = c + c = 18‬‬
‫‪‬‬
‫‪| S |= 1 ⇒ ‬‬
‫‪3, 2‬‬ ‫‪2 ,1‬‬

‫‪ g (3,{4}) = c3, 4 + c4,1 = 20‬‬

‫‪ g (4,{2}) = c + c = 13‬‬
‫‪‬‬ ‫‪4, 2‬‬ ‫‪2 ,1‬‬

‫‪ g (4,{3}) = c4,3 + c3,1 = 15‬‬

‫‪ g (2,{3,4}) = min{c2,3 + g (3,{4}), c2, 4 + g (4,{3})} = 25‬‬
‫‪‬‬ ‫‪144244‬‬ ‫‪3‬‬
‫‪min‬‬
‫‪‬‬
‫‪| S |= 2 ⇒  g (3,{2,4}) = min{c3, 2 + g (2,{4}), c3, 4 + g (4,{2})} = 25‬‬
‫‪ g (4,{2,3}) = min{c + g (2,{3}), c + g (3,{2})} = 23‬‬
‫‪‬‬ ‫‪4, 2‬‬ ‫‪4,3‬‬
‫‪‬‬
‫‪‬‬
‫‪| S |= 3 ⇒  g (1,{2,3,4}) = min{c1, 2 + g (2,{3,4}), c1,3 + g (3,{2,4}), c1, 4 + g (4,{2,3})} = 35‬‬
‫‪‬‬ ‫‪1442443‬‬
‫‪min‬‬

‫ﺗﻮﻟﻴﺪ ﺩﻭﺭ ﮐﻤﻴﻨﻪ‪ :‬ﺣﺎﻝ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻳﻨﮑﻪ ﻣﻘﺪﺍﺭ ‪ ۳۵‬ﺑﺮ ﺍﺳﺎﺱ ﮐﻤﻴﻨﻪ ﺑﻮﺩﻥ ﮐﺪﺍﻡ ﻣﻘﺪﺍﺭ ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﺍﺳﺖ ﺑﻪ ﺳـﻤﺖ ﻋﻘـﺐ‬
‫ﺑﺎﺯﻣﻴﮕﺮﺩﻳﻢ‪.‬‬
‫‪⇒ 35 = c1, 2 + g (2,{3,4}) = c1, 2 + c2, 4 + c4,3 + c3,1‬‬
‫‪14243‬‬
‫)}‪c2 , 4 + g ( 4 ,{3‬‬
‫‪1‬‬‫‪424‬‬ ‫‪3‬‬
‫‪c 4 , 3 + c3 ,1‬‬

‫ﺑﻨﺎﺑﺮﺍﻳﻦ ﺩﻭﺭ ﮐﻤﻴﻨﻪ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ‪:‬‬

‫‪١‬‬
‫‪١٠‬‬
‫‬

‫‪٣‬‬ ‫‪٢‬‬

‫‪١٠‬‬

‫‪٩‬‬ ‫‪T‬‬

‫ﺗﺤﻠﻴﻞ ﺯﻣﺎﻧﯽ‪ :‬ﺑﺎ ﮐﻤﯽ ﺩﻗﺖ ﻣﻴﺘﻮﺍﻥ ﺩﺭﻳﺎﻓﺖ ﮐﻪ ﻭﻗﺘﯽ ‪ |S|=n-1‬ﺑﺎﺷﺪ ﺗﻌﺪﺍﺩ ﻣﻘﺎﺩﻳﺮﯼ ﮐﻪ ﺑﺎﻳﺪ ﺭﻭﯼ ﺁﻧﻬﺎ ﻣﻴﻨﻴﻤﻢ ﻣﺤﺎﺳـﺒﻪ‬
‫ﮐﻨﻴﻢ ‪ n-1‬ﺍﺳﺖ ﻭ ﺩﺭ ﺑﻘﻴﻪ ﺣﺎﻻﺕ ﻭﻗﺘﯽ ‪ |S|=k‬ﺍﺳﺖ ﺩﺭ ﺭﺍﺑﻄﻪ )‪ ، g(i,S‬ﺗﻌﺪﺍﺩ ﺣﺎﻻﺗﯽ ﮐﻪ ﻣﺘﻐﻴﺮ ‪ i‬ﻣﻴﺘﻮﺍﻧﺪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‬
‫‪ n-1‬ﺣﺎﻟﺖ ﻭ ﺗﻌﺪﺍﺩ ﺣﺎﻻﺗﯽ ﮐﻪ ﻣﻴﺘﻮﺍﻥ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ‪ k‬ﻋﻀﻮﯼ ﺍﺯ ‪ n-1‬ﻋﻀﻮ ﺍﻧﺘﺨﺎﺏ ﮐﻨﻴﻢ ﺑﺮﺍﺑﺮ ﺑﺎ ﺗﺮﮐﻴـﺐ ‪ k‬ﺍﺯ ‪n-1‬‬
‫ﻣﻴﺒﺎﺷﺪ‪ .‬ﺍﺯ ﺍﻳﻦ ﺭﻭ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺮﺍﺑﺮ ﺑﺎ ﻣﻘﺪﺍﺭ ﺯﻳﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ‪:‬‬
‫‪n −2‬‬
‫‪ n − 1‬‬
‫‪(n − 1) + ∑ (n − 1)‬‬ ‫‪‬‬
‫‪k =0‬‬ ‫‪k ‬‬
 ‫‪۶‬‬

‫)‪(Backtracking‬‬ ‫ﺩ‬ ‫ﺮ‬ ‫ﮕ‬ ‫ﺒ‬ ‫ﻘ‬ ‫ﻋ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬ ‫‪-‬‬

‫ﺩﺭ ﺑﻌﻀﯽ ﺷﺮﺍﻳﻂ ﺩﺭ ﻫﻨﮕﺎﻡ ﺣﻞ ﻣﺴﺌﻠﻪ ﻧﻤﻴﺘﻮﺍﻥ ﺍﺯ ﺭﻭﺵ ﺧﺎﺻﯽ ﺍﺳـﺘﻔﺎﺩﻩ ﮐـﺮﺩ ﻭ ﺍﺯ ﺍﻳـﻦ ﺭﻭ ﻻﺯﻡ ﻣﻴﺸـﻮﺩ ﮐـﻪ ﻓﻀـﺎﯼ‬
‫ﺣﺎﻻﺕ ﺑﻄﻮﺭ ﮐﺎﻣﻞ ﺟﺴﺘﺠﻮ ﺷﺪﻩ ﺗﺎ ﺟﻮﺍﺏ ﻣﺴﺌﻠﻪ ﻣﺸﺨﺺ ﺷﻮﺩ‪ .‬ﺩﺭ ﺍﻳﻦ ﺷﺮﺍﻳﻂ ﺍﺯ ﺭﻭﺵ ﺧﺎﺻـﯽ ﺑـﻪ ﻧـﺎﻡ ﺭﻭﺵ ﭘـﻲ‪-‬‬
‫ﺟﻮﻳﻲ ﺑﻪ ﻏﻘﺐ ﻳﺎ ﺭﻭﺵ ﻋﻘﺒﮕﺮﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻴﺸﻮﺩ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺩﺭﺧﺖ ﻓﻀﺎﯼ ﺣﺎﻟـﺖ ﺑـﻪ ﺭﻭﺵ "ﻋﻤـﻖ ﺍﻭﻝ" ﺟﺴـﺘﺠﻮ‬
‫ﻣﻴﺸﻮﺩ ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﺗﺎ ﺯﻣﺎﻧﯽ ﮐﻪ ﺍﺯ ﺍﺷﺘﺒﺎﻩ ﺑﻮﺩﻥ ﻳﮏ ﻣﺴﻴﺮ ﻣﻄﻤﺌﻦ ﻧﺸـﺪﻩﺍﻳـﻢ ﺁﻥ ﻣﺴـﻴﺮ ﺭﺍ ﺍﺩﺍﻣـﻪ ﺩﺍﺩﻩ ﻭ ﺩﺭ ﺻـﻮﺭﺕ‬
‫ﺍﻃﻤﻴﻨﺎﻥ ﺍﺯ ﺍﺷﺘﺒﺎﻩ ﺑﻮﺩﻥ ﺁﻥ ﻳﮏ ﻣﺮﺣﻠﻪ ﺑﻪ ﻋﻘﺐ ﺑﺎﺯﮔﺸﺘﻪ ﻭ ﺩﻭﺑﺎﺭﻩ ﮐﺎﺭ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‪ .‬ﺍﻳﻦ ﺭﻭﻧـﺪ ﺍﺩﺍﻣـﻪ ﻣﻴﻴﺎﺑـﺪ ﺗـﺎ ﺑـﻪ‬
‫ﺟﻮﺍﺏ ﻧﻬﺎﻳﻲ ﺑﺮﺳﻴﻢ‪.‬‬
‫ﺍﻳﻦ ﺭﻭﺵ ﻳﻚ ﺭﻭﺵ ﻏﻴﺮﻫﺪﻓﻤﻨﺪ ﻣﻲﺑﺎﺷﺪ ﻛﻪ ﺩﺭ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺎﻳﺪ ﺗﻤﺎﻡ ﺣﺎﻻﺕ ﺭﺍ ﺩﺭﻧﻈﺮ ﺑﮕﻴﺮﻳﻢ ﺩﺭ ﺻﻮﺭﺗﻲﻛـﻪ ﺑﺘـﻮﺍﻧﻴﻢ‬
‫ﻳﻚ ﺳﺮﻱ ﺷﺮﻭﻁ ﺑﻨﺎ ﺑﻪ ﻣﻘﺘﻀﻴﺎﺕ ﻣﺴﺌﻠﻪ‪ ،‬ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ ﺗﺎ ﮐﻞ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﭘﻴﻤـﺎﻳﺶ ﻧﺸـﻮﺩ ﻣﻴﺘـﻮﺍﻥ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺑـﺎ ﺯﻣـﺎﻥ‬
‫ﻭﺍﻗﻌﯽ ﮐﻤﺘﺮﯼ ﺑﺪﺳﺖ ﺁﻭﺭﺩ ﻭﻟﻲ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﮐﺎﻫﺶ ﻧﻤﻴﺎﺑﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺍﻋﺪﺍﺩ ‪ ۴‬ﺑﻴﺘﯽ ﺭﺍ ﭘﻴﺪﺍ ﮐﻨﻴﺪ ﮐﻪ ﺗﻌﺪﺍﺩ ﻳﮑﻬﺎﯼ ﺁﻧﻬﺎ ﺩﻗﻴﻘﺎﹰ ‪ ۲‬ﺗﺎ ﺑﺎﺷﺪ‪.‬‬
‫ﺑﺮﺍﯼ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﺭﺍ ﺭﺳﻢ ﻣﻴﮑﻨﻴﻢ‪:‬‬

‫=‪A1‬‬ ‫‪1‬‬ ‫‪0‬‬

‫=‪A2‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪0‬‬ ‫‪1‬‬

‫‪A3= 1‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬

‫‪0‬‬

‫‪1‬‬ ‫‬
‫‬ ‫‪1‬‬ ‫‪0 1‬‬ ‫‪0 1‬‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪0 1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫=‪A4‬‬

‫ ‬ ‫‬ ‫ ‬ ‫‬ ‫‬ ‫‬ ‫‬

‫‬ ‫‬ ‫‬
‫‪٧٠‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫ﺩﺭ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﻫﻨﮕﺎﻣﯽ ﮐﻪ ﻣﻄﻤﺌﻦ ﻫﺴﺘﻴﻢ ﮐﻪ ﺍﻳﻦ ﻣﺴﻴﺮ ﺑﻪ ﺟﻮﺍﺏ ﺩﺭﺳﺖ ﻣﻨﺠﺮ ﻧﺨﻮﺍﻫﺪ ﺷﺪ ﻋﻤﻞ ﻋﻘﺒﮕـﺮﺩ ﺻـﻮﺭﺕ‬
‫ﻣﻴﮕﻴﺮﺩ ﮐﻪ ﺩﺭ ﺷﮑﻞ ﺑﺎ ﻋﻼﻣﺖ  ﻣﺸﺨﺺ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺗﻮﺳﻂ ﮐﺪ ﺯﻳـﺮ ﻣﻴﺘـﻮﺍﻥ ﻓﻀـﺎﯼ ﺣﺎﻟـﺖ ﺭﺳـﻢ ﺷـﺪﻩ ﺩﺭ ﺑـﺎﻻ ﺭﺍ‬
‫ﺗﺸﮑﻴﻞ ﺩﺍﺩ ﻭ ﺑﻪ ﺟﻮﺍﺏ ﺭﺳﻴﺪ‪:‬‬
‫)‪procedure BT(A, i, n‬‬
‫)‪f1←sum(A,n‬‬
‫‪if i>n then‬‬
‫‪if f1= 2 then write(A) endif‬‬
‫‪else‬‬
‫‪if f1>2 or 2-f1>n-i then return endif‬‬ ‫)*(‬
‫‪A[i] ←1‬‬
‫)‪BT(A,i+1,n‬‬
‫‪A[i] ←0‬‬
‫)‪BT(A,i+1,n‬‬
‫‪endif‬‬
‫‪end.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻓﺮﺍﺧﻮﺍﻧﯽ ﺍﻭﻟﻴﻪ ﺭﻭﻳﻪ ﺑﺎﻻ ﺑﺎﻳﺪ ﺑﺼﻮﺭﺕ )‪ BT(A,1,4‬ﺻﻮﺭﺕ ﮔﻴﺮﺩ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺗﺎﺑﻊ ‪ sum‬ﺩﺭ ﮐﺪ ﺑﺎﻻ ﺗﻌﺪﺍﺩ ﻳﮑﻬﺎﯼ ﺭﺷﺘﻪ ‪ A‬ﺭﺍ ﺗﺎ ﻣﺮﺣﻠﻪ ﻓﻌﻠﯽ )‪ i-1‬ﺍﻡ( ﻣﺤﺎﺳﺒﻪ ﻣﻴﮑﻨﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺷﺮﻁ ﻣﺸﺨﺺ ﺷﺪﻩ ﺩﺭ )*( ﺑﺮﺭﺳﯽ ﻣﻴﮑﻨﺪ ﮐﻪ ﺩﺭ ﺻﻮﺭﺗﯽ ﮐﻪ ﻣﺴﻴﺮ ﻓﻌﻠﯽ ﻣﻨﺠﺮ ﺑﻪ ﺟﻮﺍﺏ ﺩﺭﺳـﺖ ﻧﺨﻮﺍﻫـﺪ ﺷـﺪ‬
‫ﻋﻤﻞ ﺑﺎﺯﮔﺸﺖ ﺑﻪ ﻋﻘﺐ )‪ (Backtrack‬ﺭﺍ ﺍﻧﺠﺎﻡ ﻣﻴﺪﻫﺪ‪ .‬ﺷﺮﻁ ﺍﻭﻝ ﺁﻥ ﻧﺸـﺎﻧﺪﻫﻨﺪﻩ ﺑـﻴﺶ ﺍﺯ ﺣـﺪ ﻣﺠـﺎﺯ ﺑـﻮﺩﻥ ﺗﻌـﺪﺍﺩ‬
‫ﻳﮑﻬﺎﺳﺖ ﻭ ﺷﺮﻁ ﺩﻭﻡ ﺁﻥ ﻧﺸﺎﻧﺪﻫﻨﺪﻩ ﮐﻤﺘﺮ ﺍﺯ ﺣﺪ ﻣﺠﺎﺯ ﺑﻮﺩﻥ ﺗﻌﺪﺍﺩ ﺑﻴﺘﻬﺎﯼ ﻣﺸﺨﺺ ﻧﺸﺪﻩ ﺗﺎ ﺑﺤﺎﻝ ﻣﻴﺒﺎﺷﺪ ﮐـﻪ ﻫـﺮ ﺩﻭ‬
‫ﺷﺮﻁ ﺩﻟﻴﻞ ﻏﻠﻂ ﺑﻮﺩﻥ ﻣﺴﻴﺮ ﻓﻌﻠﯽ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﮐﺪ ﺑﺎﻻ )‪ O(2n‬ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻫﺮﭼﻪ ﺗﻌﺪﺍﺩ ﺷﺮﻃﻬﺎﯼ ﺩﺳﺘﻮﺭ )*( ﺑﻴﺸﺘﺮ ﺑﺎﺷﺪ ﻳﻌﻨﯽ ﺩﺭ ﺩﺭﺧﺖ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﺯﻭﺩﺗﺮ ﻋﻘﺒﮕﺮﺩ ﻣﻴﮑﻨﻴﻢ ﻭ ﺍﻳﻦ ﻣﻨﺠـﺮ‬
‫ﺑﻪ ﮐﻢ ﺷﺪﻥ ﺯﻣﺎﻥ ﻭﺍﻗﻌﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬
‫ﺣﺎﻝ ﺑﻪ ﺍﺭﺍﺋﻪ ﻣﺜﺎﻟﯽ ﺩﻳﮕﺮ ﺩﺭ ﺍﻳﻦ ﺭﺍﺑﻄﻪ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬

‫‪۱‬‬ ‫‪۶‬‬

‫ﺕ‬

‫ﺎ‬ ‫ﻛ‬ ‫ﺮ‬ ‫ﺗ‬ ‫ﻟ‬ ‫ﻮ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺒ‬ ‫ﻴ‬ ‫ﺪ‬

‫ﺩﺭ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻣﺠﻤﻮﻋﻪ ﺑﺎ ‪ n ≥ 1‬ﻋﻀﻮ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻭ ﺗﺼﻤﻴﻢ ﺩﺍﺭﻳﻢ ﺗﻤﺎﻡ ﺗﺮﻛﻴﺒﺎﺕ ﻣﻤﻜﻦ ﺁﻥ ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷـﻴﻢ‪ .‬ﺍﻳـﻦ‬
‫ﺭﻭﺵ ﺩﺍﺭﺍﻱ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ )!‪ (n‬ﻣﻲﺑﺎﺷﺪ‪ .‬ﺑﺮﺍﻱ ﺣﻞ ﻣﺴﺌﻠﻪ ﻣﺎ ﺍﺯ ﺭﻭﺵ ‪ Backtracking‬ﺍﺳﺘﻔﺎﺩﻩ ﻣﻲﻛﻨﻴﻢ‪.‬‬
‫)‪Procedure perm(A, k, n‬‬
‫‪if k=n then‬‬
‫)‪write(A‬‬
‫‪else‬‬
‫‪for i←k to n do‬‬
‫)]‪swap(A[k],A[i‬‬
‫)‪perm(A,k+1,n‬‬
‫‪repeat‬‬
‫‪endif‬‬
‫‪end.‬‬
 ٧١ (Backtracking)


   ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫ ﺭﺍ‬perm(A,1,n) ‫ ﻗـﺮﺍﺭ ﺩﺍﺩﻩ ﻭ ﺳـﭙﺲ‬A ‫ ﺭﺍ ﺩﺭ ﺁﺭﺍﻳﻪ‬n ‫ ﺗﺎ‬1 ‫ ﺍﺑﺘﺪﺍ ﺑﺎﻳﺪ ﻋﻨﺎﺻﺮ‬perm ‫ ﺩﺭ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺍﻭﻟﻴﻪ ﺭﻭﻳﻪ‬:‫ﻧﮑﺘﻪ‬
.‫ﻓﺮﺍﺧﻮﺍﻧﯽ ﮐﻨﻴﻢ‬

‫ ﺗﻮﻟﻴﺪ ﻛﻨﻴﺪ؟‬perm ‫ ﺭﺍ ﺑﻪ ﻭﺳﻴﻠﻪ ﭘﺮﻭﺳﻴﺠﺮ‬a,b,c ‫ ﺗﻤﺎﻡ ﺗﺮﻛﻴﺒﺎﺕ ﻣﻤﻜﻦ‬:‫ﻣﺜﺎﻝ‬

a c
b

a ? b ? c ?

a
b c a c b

ab ? ac ? ba ? bc ? cb ? ca ?

c b c a b a
abc acb bac bca cba cab

:‫ﻧﺤﻮﻩ ﻓﺮﺍﺧﻮﺍﻧﯽ ﺑﺎﺯﮔﺸﺘﯽ ﺭﻭﻳﻪ ﺑﺼﻮﺭﺕ ﺷﮑﻞ ﺯﻳﺮ ﻣﻴﺒﺎﺷﺪ‬

perm(A=abc,k=3,n=3)
perm(A=abc,k=2,n=3)
perm(A=acb,k=3,n=3)

perm(A=bac,k=3,n=3)
perm(A=abc,k=1,n=3) perm(A=bac,k=2,n=3)

perm(A=bca,k=3,n=3)

perm(A=cba,k=3,n=3)

perm(A=cba,k=2,n=3)
perm(A=cab,k=3,n=3)
‫‪٧٢‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫ﻳﺎ ﺷﻜﻞ ﺳﺎﺩﻩﺗﺮ‬

‫‪c‬‬
‫‪a‬‬
‫‪b‬‬

‫‪b‬‬ ‫‪a‬‬ ‫‪c‬‬ ‫‪a‬‬

‫‪c‬‬ ‫‪b‬‬

‫‪c‬‬ ‫‪b‬‬
‫‪c‬‬ ‫‪a‬‬ ‫‪a‬‬ ‫‪b‬‬

‫‪abc‬‬ ‫‪acb‬‬ ‫‪bac‬‬ ‫‪bca‬‬ ‫‪cba‬‬ ‫‪cab‬‬

‫‪n‬‬
‫‪٦‬‬
‫‪٢‬‬

‫ﻪ‬ ‫ﻠ‬ ‫ﺌ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺮ‬ ‫ﻳ‬ ‫ﺯ‬ ‫ﻭ‬

‫ﺣﺎﻝ ﺑﻪ ﻃﺮﺡ ﻣﺴﺌﻠﻪﺍﯼ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ ﮐﻪ ﺩﺭ ﺍﺭﺍﺋﻪ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺮﺍﯼ ﺁﻥ ﺍﺯ ﺭﻭﺵ ﻋﻘﺒﮕﺮﺩ ﺍﺳﺘﻔﺎﺩﻩ ﻣﻴﮑﻨﻴﻢ‪ .‬ﺩﺭ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﻫـﺪﻑ‬
‫ﻗﺮﺍﺭ ﺩﺍﺩﻥ ‪ n‬ﻣﻬﺮﻩ ﻭﺯﻳﺮ ﺩﺭ ﺻﻔﺤﻪ ﺷﻄﺮﻧﺞ )‪ (n*n‬ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﺍﺳﺖ ﮐﻪ ﻫﻴﭽﻴﮏ ﺍﺯ ﻭﺯﻳﺮﺍﻥ ﺩﻳﮕﺮﯼ ﺭﺍ ﺗﻬﺪﻳﺪ ﻧﮑﻨـﺪ‪ .‬ﺩﺭ‬
‫ﻣﺴﺌﻠﻪ ‪ n‬ﻭﺯﻳﺮ ﻓﺮﺽ ﺩﺭ ﻫﻴﭻ ﺳﻄﺮ ﻭ ﺳﺘﻮﻧﻲ ﺑﻴﺶ ﺍﺯ ﻳﻚ ﻭﺯﻳﺮ ﻗﺮﺍﺭ ﻧﮕﻴﺮﺩ‪ .‬ﺣﺎﻝ ﺑﺎ ﺍﻳـﻦ ﻓـﺮﺽ ﺗﻤـﺎﻡ ﺟﺎﻳﮕﺸـﺖﻫـﺎﻱ‬
‫ﻣﻤﻜﻦ ﺭﺍ ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﻴﻢ ﻳﻌﻨﻲ ﻫﻤﺎﻥ ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ ﻳﺎ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﺭﺍ ﺑﻮﺟﻮﺩ ﻣﻲﺁﻭﺭﻳﻢ ﺳﭙﺲ ﺩﺭ ﻫﺮﻣﺮﺣﻠﻪ ﺑﺮﺭﺳﯽ‬
‫ﻣﻲﻛﻨﻴﻢ ﻛﻪ ﻣﺴﻴﺮ ﻓﻌﻠﯽ ﺩﺭ ﺩﺭﺧﺖ ﺑﺎ ﺍﻳﻦ ﻧﺤﻮﻩﺍﻱ ﭼﻴﺪﻣﺎﻥ ﻭﺯﻳﺮﻫﺎ ﺁﻳﺎ ﺩﺍﺭﺍﻱ ﺷـﺮﺍﻳﻂ ﻣﺴـﺌﻠﻪ ﻣـﻲﺑﺎﺷـﺪ ﻳﻌﻨـﻲ ﻭﺯﻳﺮﻫـﺎ‬
‫ﻳﻜﺪﻳﮕﺮ ﺭﺍ ﺗﻬﺪﻳﺪ ﻣﻲﻛﻨﻨﺪ ﻳﺎ ﺧﻴﺮ‪ .‬ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺑﺮﺍﯼ ‪ n=4‬ﻣﺴﺌﻠﻪ ﺩﺍﺭﺍﯼ ﺩﻭ ﺟﻮﺍﺏ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ‪.‬‬

‫ﺟﻮﺍﺏ ﺍﻭﻝ‪:‬‬

‫*‬
‫*‬
‫*‬
‫*‬
‫ﮐﻪ ﺗﻮﺳﻂ ﺁﺭﺍﻳﻪ ﺯﻳﺮ ﻗﺎﺑﻞ ﻧﻤﺎﻳﺶ ﺍﺳﺖ‪:‬‬
‫‪٧٣‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫‪۲ ۴ ۱ ۳‬‬

‫ﺟﻮﺍﺏ ﺩﻭﻡ‪:‬‬
‫*‬
‫*‬
‫*‬
‫*‬

‫ﮐﻪ ﺗﻮﺳﻂ ﺁﺭﺍﻳﻪ ﺯﻳﺮ ﻗﺎﺑﻞ ﻧﻤﺎﻳﺶ ﺍﺳﺖ‪:‬‬

‫‪۳ ۱ ۴ ۲‬‬

‫ﺍﮔﺮ ‪ n‬ﺑﺮﺍﺑﺮ ‪ ٥‬ﺑﺎﺷﺪ ‪ ٥‬ﺟﻮﺍﺏ ﺑﺮﺍﯼ ﻣﺴﺌﻠﻪ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻭ ﺑﺮﺍﯼ ‪ ۹۲ n=8‬ﺟﻮﺍﺏ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬

‫ﻧﮑﺘﻪ‪ :‬ﭼﻮﻥ ﺩﺭ ﻫﺮ ﻟﺤﻈﻪ ﺩﺭ ﻳﮏ ﺳﻄﺮ ﻭ ﻳﮏ ﺳﺘﻮﻥ ﻧﻤﻴﺘﻮﺍﻧﺪ ﺑﻴﺶ ﺍﺯ ﻳﮏ ﻭﺯﻳﺮ ﻗﺮﺍﺭ ﮔﻴﺮﺩ ﻟﺬﺍ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳـﮏ ﻣـﺎﺗﺮﻳﺲ‬
‫ﻣﻮﺭﺩ ﻟﺰﻭﻡ ﻧﻴﺴﺖ ﻭ ﻓﻘﻂ ﻳﮏ ﺁﺭﺍﻳﻪ ﻳﮏ ﺑﻌﺪﯼ ‪ n‬ﻋﻨﺼﺮﯼ ﮐﻔﺎﻳﺖ ﻣﻴﮑﻨﺪ‪ .‬ﺩﺭ ﺍﻳﻦ ﺁﺭﺍﻳﻪ ﻧﻴـﺰ ﺍﮔـﺮ ﻓـﺮﺽ ﺯﻳـﺮ ﺭﺍ ﺍﻧﺠـﺎﻡ‬
‫ﺩﻫﻴﻢ‪:‬‬

‫ﺳﺘﻮﻥ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ ﻭﺯﻳﺮ ‪ i‬ﺍﻡ = ]‪A[i‬‬

‫ﺁﻧﮕﺎﻩ ﻋﻨﺎﺻﺮ ﺗﮑﺮﺍﺭﯼ ﺩﺭ ﺁﺭﺍﻳﻪ ﻧﺒﺎﻳﺪ ﻭﺟﻮ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻭ ﺍﺯ ﺍﻳﻦ ﺭﻭ ﻣﻴﺘـﻮﺍﻥ ﺍﺯ ﻫﻤـﺎﻥ ﺭﻭﻳـﻪ ‪ perm‬ﺑـﺮﺍﯼ ﺗﻮﻟﻴـﺪ ﻫﻤـﻪ‬
‫ﺟﺎﻳﮕﺸﺘﻬﺎ ﺩﺭ ﺁﺭﺍﻳﻪ ﺍﺳﺘﻔﺎﺩﻩ ﮐﺮﺩ ﻭ ﻓﻘﻂ ﻫﻨﮕﺎﻡ ﭼﺎﭖ ﺧﺮﻭﺟﻲ ﺷﺮﻃﻲ ﺭﺍ ﺑﺮﺍﻱ ﭼﺎﭖ ﺩﺭ ﺧﺮﻭﺟـﻲ ﻗـﺮﺍﺭ ﻣـﻲﺩﻫـﻴﻢ ﻛـﻪ‬
‫ﻫﻤﺎﻥ ﺗﺎﺑﻊ ‪ test‬ﻣﻲﺑﺎﺷﺪ ﮐﻪ ﮐﺪ ﺩﺭ ﺯﻳﺮ ﺁﻭﺭﺩﻩ ﺷﺪﻩ ﺍﺳﺖ‪ .‬ﺑﺮﺭﺳﯽ ﺍﻳﻨﮑﻪ ﺁﻳﺎ ﻭﺯﻳﺮﻫﺎﯼ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻪ ﺩﺭ ﺁﺭﺍﻳـﻪ ﻫﻤـﺪﻳﮕﺮ ﺭﺍ‬
‫ﺗﻬﺪﻳﺪ ﻣﻴﮑﻨﻨﺪ ﻳﺎ ﺧﻴﺮ ﺑﻪ ﺭﺍﺣﺘﯽ ﺗﻮﺳﻂ ﺭﺍﺑﻄﻪ ﺯﻳﺮ ﻗﺎﺑﻞ ﺍﻧﺠﺎﻡ ﺍﺳﺖ‪ .‬ﺑﻪ ﺍﻳﻦ ﻣﻌﻨﯽ ﮐﻪ ﺍﮔﺮ ﻋﻨﺎﺻـﺮ ﻗـﺮﺍﺭ ﮔﺮﻓﺘـﻪ ﺩﺭ ﺁﺭﺍﻳـﻪ‬
‫ﺩﺍﺭﺍﯼ ﺍﻳﻦ ﺧﺎﺻﻴﺖ ﺑﺎﺷﻨﺪ ﻫﻴﭽﮕﺎﻩ ﺩﻭ ﻭﺯﻳﺮ ﻳﮑﺪﻳﮕﺮ ﺭﺍ ﺗﻬﺪﻳﺪ ﻧﻤﻴﮑﻨﻨﺪ‪:‬‬

‫| ‪∀ i, j | i ≠ j ⇒ | A[i ] − A[ j ] | ≠| i − j‬‬

‫)‪Procedure Queen(A, k, n‬‬

‫‪if k=n then‬‬
‫‪if test(A,n) then write(A) endif‬‬
‫‪else‬‬
‫‪for i←k to n do‬‬
‫)]‪swap(A[k],A[i‬‬
‫)‪perm(A,k+1,n‬‬
‫‪repeat‬‬
‫‪endif‬‬
‫‪end.‬‬
‫‪٧٤‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫)‪function test(A,n‬‬
‫‪for i←1 to n do‬‬
‫‪for j←i+1 to n do‬‬
‫‪if | A[i] – A[j] | = | i-j | then return false endif‬‬
‫‪repeat‬‬
‫‪repeat‬‬
‫‪return true‬‬
‫‪end.‬‬

‫ﻧﮑﺘﻪ‪ :‬ﺍﻟﮕﻮﺭﻳﺘﻢ ‪ Queen‬ﺩﺍﺭﺍﻱ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﻲ )!‪ O(n‬ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫ﻁ‬

‫‪x‬‬
‫ﺍ‬ ‫ﺍ‬

‫‪٣‬‬ ‫‪٦‬‬

‫ﺎ‬ ‫ﻬ‬ ‫ﻧ‬ ‫ﺁ‬ ‫ﻞ‬ ‫ﻮ‬ ‫ﻓ‬ ‫ﻱ‬ ‫ﻭ‬ ‫ﺭ‬ ‫ﺯ‬ ‫ﺎ‬ ‫ﻫ‬ ‫ﺭ‬ ‫ﻮ‬ ‫ﻣ‬ ‫ﻱ‬ ‫ﻭ‬ ‫ﺭ‬ ‫ﺎ‬ ‫ﻘ‬ ‫ﻧ‬ ‫ﻦ‬ ‫ﻌ‬ ‫ﺗ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺻ‬ ‫ﺤ‬ ‫ﻴ‬ ‫ﻴ‬

‫) ‪( x 1 , x 2 ,....., x n‬‬ ‫ﻭﺭﻭﺩﻱ‪ :‬ﻣﺠﻤﻮﻋﻪ ﻓﻮﺍﺻﻞ‪ n‬ﻧﻘﻄﻪ‬

‫ﺧﺮﻭﺟﻲ‪x 1 ≤ x 2 ≤ ..... ≤ x n :‬‬

‫ﻣﻴﺘﻮﺍﻥ ﺗﻮﺳﻂ ﺭﺍﺑﻄﻪ ﺯﻳﺮ ﺗﻌﺪﺍﺩ ﻓﻮﺍﺻﻠﯽ ﮐﻪ ‪ n‬ﻧﻘﻄﻪ ﻣﻴﺘﻮﺍﻧﻨﺪ ﺑﺎ ﻳﮑﺪﻳﮕﺮ ﺗﻮﻟﻴﺪ ﮐﻨﻨﺪ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﺩ‪:‬‬
‫)‪n ( n − 1‬‬ ‫‪n ‬‬
‫= ‪D‬‬ ‫‪= ‬‬
‫‪2‬‬ ‫‪2 ‬‬

‫ﺑﺮﺍﯼ ﺟﻠﻮﮔﻴﺮﯼ ﺍﺯ ﻋﺪﻡ ﺗﻮﻟﻴﺪ ﺟﻮﺍﺑﻬﺎﯼ ﺑﺪﻳﻬﯽ ﻭ ﻣﻨﻔﯽ ﻓﺮﺽ ﻣﻴﮑﻨﻴﻢ ﮐﻪ ‪ X1=0‬ﻭ ﺑﻘﻴﻪ ﻧﻘﺎﻁ ﻫﻤﮕﯽ ﻣﺜﺒﺖ ﻫﺴﺘﻨﺪ‪.‬‬

‫}‪D = {1, 2, 2, 2,3,3, 4, 5, 5, 6, 7, 7,8,9,10‬‬

‫ﻣﺜﺎﻝ‪:‬‬

‫ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﺑﺰﺭﮔﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ ﺭﺍ ﺍﺯ ﻣﺠﻤﻮﻋﻪ ﻓﻮﺍﺻﻞ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩﻩ‪ ،‬ﺍﻳﻦ ﻋﺪﺩ ﻳﺎ ﻓﺎﺻﻠﻪ ﺍﻭﻟـﻴﻦ ﻧﻘﻄـﻪ )‪ (x0‬ﺑـﺎ ﺁﺧـﺮﻳﻦ‬
‫ﻧﻘﻄﻪ ﻧﺎﻣﻌﻠﻮﻡ ﻭ ﻳﺎ ﻓﺎﺻﻠﻪ ﺁﺧﺮﻳﻦ ﻧﻘﻄﻪ )‪ (x6‬ﺑﺎ ﺍﻭﻟﻴﻦ ﻧﻘﻄﻪ ﻧﺎﻣﻌﻠﻮﻡ ﻣﻴﺒﺎﺷﺪ‪) .‬ﺩﺭ ﻫﺮ ﮔﺮﻩ ﻣﺴﻴﺮ ﺍﺯ ﺭﻳﺸﻪ ﺗﺎ ﺁﻥ ﮔﺮﻩ ﻧﺸـﺎﻥ‬
‫ﺩﻫﻨﺪﻩ ﻧﻘﺎﻁ ﻣﻌﻠﻮﻡ ﺗﺎ ﺁﻥ ﻟﺤﻈﻪ ﻣﻴﺒﺎﺷﻨﺪ‪ (.‬ﺑﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻦ ﺍﻳﻦ ﺩﻭ ﺣﺎﻟﺖ ﺑﻪ ﺩﻭ ﻧﻘﻄﻪ ﻣﻌﻠﻮﻡ ﺟﺪﻳـﺪ ﻣﺮﺳـﻴﻢ ﻭ ﻓﻮﺍﺻـﻞ‬
‫ﺑﻮﺟﻮﺩ ﺁﻧﺪﻩ ﺗﻮﺳﻂ ﺁﻥ ﻧﻘﺎﻁ ﺭﺍ ﺑﺎ ﻧﻘﺎﻁ ﻣﻌﻠﻮﻡ ﻗﺒﻠﯽ )ﺩﺭ ﺻﻮﺭﺕ ﻭﺟﻮﺩ( ﺍﺯ ﻣﺠﻤﻮﻋـﻪ ﻓﻮﺍﺻـﻞ ﺧـﻂ ﻣﻴـﺰﻧﻴﻢ‪ .‬ﺍﮔـﺮ ﺍﻳـﻦ‬
‫ﻓﻮﺍﺻﻞ ﻣﻮﺟﻮﺩ ﻧﺒﻮﺩﻧﺪ ﺷﺎﺧﻪ ﻗﻄﻊ ﺷﺪﻩ ﻭ ﺷﺎﺧﻪ ﺩﻳﮕﺮﯼ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‪.‬‬
 ‫‪٧٥‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫‪x0 =0‬‬
‫ﺑﺎ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ‪ x6=10‬ﻓﺎﺻﻠﻪ ‪ x0‬ﺑﺎ ‪ x6‬ﺑﺮﺍﺑﺮ ‪۱۰‬‬
‫ﺧﻮﺍﻫﺪ ﺷﺪ ﺑﻨﺎﺑﺮ ﺍﻳﻦ ﻋﺪﺩ ‪ ۱۰‬ﺭﺍ ﺍﺯ ﻣﺠﻤﻮﻋﻪ‬
‫ﺑﺎ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ‪ x2=1‬ﻓﺎﺻﻠﻪ ‪ x0‬ﻭ ‪ x6‬ﺑﺎ ‪ x2‬ﺑﺮﺍﺑﺮ ‪۱‬‬ ‫ﻓﻮﺍﺻﻞ ﺧﻂ ﻣﻴﺰﻧﻴﻢ‬
‫ﻭ ‪ ۹‬ﺧﻮﺍﻫﺪ ﺷﺪ ﺑﻨﺎﺑﺮ ﺍﻳﻦ ﺍﻋﺪﺍﺩ ‪۱‬ﻭ‪ ۹‬ﺭﺍ ﺍﺯ‬
‫‪x 6 = 10‬‬
‫ﻣﺠﻤﻮﻋﻪ ﻓﻮﺍﺻﻞ ﺧﻂ ﻣﻴﺰﻧﻴﻢ‬

‫ﺑﺮﺍﻱ ﺗﻮﻟﻴﺪ ﻫﻤﻪ ﺟﻮﺍﺑﻬﺎ ﺑﺎﻳـﺪ ﺍﻳـﻦ ﺷـﺎﺧﻪ ﺭﺍ ﻧﻴـﺰ‬

‫‪x 2 =1‬‬ ‫‪x5 =9‬‬ ‫ﺍﺩﺍﻣﻪ ﺩﺍﺩ‪ .‬ﺑﺎ ﺍﺩﺍﻣﻪ ﺍﻳﻦ ﺷﺎﺧﻪ ﺟﻮﺍﺏ ﺩﻳﮕﺮﯼ ﺗﻮﻟﻴـﺪ‬
‫ﻣﻴﺸﻮﺩ‪{0,2,4,7,9,10} :‬‬

‫‪x3 = 2‬‬
‫‪x5 =8‬‬
‫ﺑﺎ ﻗﺮﺍﺭ ﺩﺍﺩﻥ ‪ x5=1‬ﻓﺎﺻﻠﻪ ‪ x0‬ﻭ ‪ x6‬ﻭ ‪ x2‬ﺑﺎ ‪x5‬‬
‫ﺑﺮﺍﺑﺮ ‪ ۸‬ﻭ ‪ ۲‬ﻭ ‪ ۷‬ﺧﻮﺍﻫﺪ ﺷﺪ ﺑﻨﺎﺑﺮ ﺍﻳﻦ ﺍﻋﺪﺍﺩ ‪ ۸‬ﻭ‬
‫‪۲‬ﻭ ‪ ۷‬ﺭﺍ ﺍﺯ ﻣﺠﻤﻮﻋﻪ ﻓﻮﺍﺻﻞ ﺧﻂ ﻣﻴﺰﻧﻴﻢ‬

‫ﺍﻳﻦ ﺷﺎﺧﻪ ﻗﻄﻊ ﻣﻴﺸﻮﺩ ﭼﻮﻥ ‪ x3=2‬ﻧﻤﻴﺘﻮﺍﻧﺪ ﺻﺤﻴﺢ‬

‫‪x4 =7‬‬
‫ﺑﺎﺷﺪ ﭼﻮﻥ ﻓﺎﺻﻠﻪ ﺁﻥ ﺑﺎ ‪ x2‬ﺑﺮﺍﺑﺮ ﺑﺎ ‪ ۱‬ﺧﻮﺍﻫﺪ ﺷﺪ‬ ‫‪x3 =3‬‬
‫ﮐﻪ ‪ ۱‬ﺟﺰﻭ ﻓﻮﺍﺻﻞ ﻣﻮﺟﻮﺩ ﻧﻴﺴﺖ‬

‫ﺍﻳﻦ ﺷﺎﺧﻪ ﻗﻄﻊ ﻣﻴﺸﻮﺩ ﭼﻮﻥ ‪ x4=7‬ﻧﻤﻴﺘﻮﺍﻧﺪ‬

‫ﺻﺤﻴﺢ ﺑﺎﺷﺪ ﭼﻮﻥ ﻓﺎﺻﻠﻪ ﺁﻥ ﺑﺎ ‪ x3‬ﺑﺮﺍﺑﺮ ﺑﺎ ‪۱‬‬ ‫‪x4 = 4‬‬ ‫‪x4 =6‬‬
‫ﺧﻮﺍﻫﺪ ﺷﺪ ﮐﻪ ‪ ۱‬ﺟﺰﻭ ﻓﻮﺍﺻﻞ ﻣﻮﺟﻮﺩ ﻧﻴﺴﺖ‬

‫ﺍﻳﻦ ﻣﺴﻴﺮ ﺍﺯ ﺭﻳﺸﻪ ﺗﺎ ﺍﻳﻦ ﮔﺮﻩ ﻳﮏ ﺟﻮﺍﺏ ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﺪ‬

‫ﺍﻳﻦ ﺷﺎﺧﻪ ﻗﻄﻊ ﻣﻴﺸﻮﺩ ﭼﻮﻥ ‪ x4=4‬ﻧﻤﻴﺘﻮﺍﻧﺪ‬
‫ﺻﺤﻴﺢ ﺑﺎﺷﺪ ﭼﻮﻥ ﻓﺎﺻﻠﻪ ﺁﻥ ﺑﺎ ‪ x3‬ﺑﺮﺍﺑﺮ ﺑﺎ ‪۱‬‬
‫ﺧﻮﺍﻫﺪ ﺷﺪ ﮐﻪ ‪ ۱‬ﺟﺰﻭ ﻓﻮﺍﺻﻞ ﻣﻮﺟﻮﺩ ﻧﻴﺴﺖ‬

‫ﺟﻮﺍﺏ ﺍﻭﻝ‪:‬‬
‫‪x1‬‬ ‫‪x2‬‬ ‫‪x3‬‬ ‫‪x4‬‬ ‫‪x5‬‬ ‫‪x6‬‬
‫‪٠‬‬ ‫‪١‬‬ ‫‪٣‬‬ ‫‪٦‬‬ ‫‪٨‬‬ ‫‪١٠‬‬

‫ﺗﻮﺿﻴﺢ‪ :‬ﻧﻮﺩ ﺍﻭﻝ ﺭﺍ ﻓﺮﺽ ﻣﻲﻛﻨﻴﻢ ﺻﻔﺮ ﺍﺳﺖ ﺑﺰﺭﮔﺘﺮﻳﻦ ﻓﺎﺻﻠﻪ‪ ،‬ﻓﺎﺻﻠﻪ ﻧـﻮﺩ ﺍﻭﻝ ﻭ ﺁﺧـﺮ ﻣـﻲﺑﺎﺷـﺪ‪ .‬ﺍﻳـﻦ ﻓﺎﺻـﻠﻪ ﺭﺍ ﺍﺯ‬
‫ﻣﺠﻤﻮﻉ ﻓﻮﺍﺻﻞ ﺣﺬﻑ ﻛﺮﺩﻩ ﻭ ﺩﻭﺑﺎﺭﻩ ﺍﺯ ﻣﺠﻤﻮﻉ ﻓﻮﺍﺻﻞ ﺑﺎﻗﻲﻣﺎﻧﺪﻩ ﻣﺎﻛﺰﻳﻤﻢ ﻓﺎﺻﻠﻪ ﺭﺍ ﭘﻴﺪﺍ ﻣﻲﻛﻨﻴﻢ ﻛﻪ ‪ ٢‬ﺣﺎﻟـﺖ ﭘـﻴﺶ‬
‫ﻣﻲﺁﻳﺪ‪:‬‬
‫‪ -۱‬ﻓﺎﺻﻠﻪ ﺭﺃﺱ ﺍﻭﻝ ﺗﺎ ﻧﻮﺩ ‪ n-1‬ﺍﻡ ﺑﺮﺍﺑﺮ ﺍﻳﻦ ﻓﺎﺻﻠﻪ ﻣﻲﺑﺎﺷﺪ‪.‬‬
‫‪٧٦‬‬ ‫)‪(Backtracking‬‬
‫
‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫ش‬ ‫و‬ ‫ر‬

‫د‬

‫‪ -۲‬ﻓﺎﺻﻠﻪ ﺭﺃﺱ ﺁﺧﺮ ﺑﺎ ﻧﻮﺩ ﺩﻭﻡ ﺑﺮﺍﺑﺮ ﺍﻳﻦ ﻓﺎﺻﻠﻪ ﻣﻲﺑﺎﺷﺪ‪.‬‬

‫ﻭ ﺩﺭ ﻫﺮﻣﺮﺣﻠﻪ ﻫﺮ ﻓﺎﺻﻠﻪﺍﻱ ﻛﻪ ﻫﺮ ﻧﻘﻄﻪ ﺑﺎ ﻧﻘﺎﻁ ﺩﻳﮕﺮ ﭘﻴﺪﺍ ﻣﻲﻛﻨﺪ ﺍﺯ ﻣﺠﻤﻮﻋﻪ ﻓﻮﺍﺻﻞ ﺣﺬﻑ ﻣﻲﻛﻨﻴﻢ ﻭ ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﺗـﺎ‬
‫ﺗﻤﺎﻣﻲ ﺍﻳﻦ ﻓﺎﺻﻠﻪﻫﺎ ﺣﺬﻑ ﺷﻮﻧﺪ ﺍﺩﺍﻣﻪ ﻣﻲﺩﻫﻴﻢ‪.‬‬
‫ﺍﮔﺮ ﻓﺎﺻﻠﻪﺍﻱ ﺩﺭ ﻣﺠﻤﻮﻉ ﻓﻮﺍﺻﻞ ﻧﺒﻮﺩ ﻣﺴﻴﺮ ﺭﺍ ﺍﺷﺘﺒﺎﻩ ﺁﻣﺪﻩﺍﻳﻢ ﺷﺎﺧﻪ ﺭﺍ ﻗﻄﻊ ﮐﺮﺩﻩ ﻭ ﺷﺎﺧﻪ ﺩﻳﮕﺮﯼ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺮﺗﺒﻪﺍﻱ ﺯﻣﺎﻧﻲ ﺍﻳﻦ ﺍﻟﮕﻮﺭﻳﺘﻢ )‪ O(n2‬ﻣﻲﺑﺎﺷﺪ!‪.‬‬
 ‫‪۷‬‬

‫)‪(Branch & Bound‬‬

‫ﺪ‬ ‫ﺪ‬

‫ﻧ‬

‫ﻳ‬ ‫ﺤ‬ ‫ﺗ‬ ‫ﻭ‬ ‫ﺏ‬ ‫ﺎ‬ ‫ﻌ‬ ‫ﺸ‬ ‫ﺍ‬ ‫ﺵ‬ ‫ﻭ‬ ‫ﺭ‬ ‫‪-‬‬

‫ﺭﻭﺵ ﺩﻳﮕﺮﯼ ﮐﻪ ﺩﺭ ﺍﻳﻦ ﻗﺴﻤﺖ ﺑﻪ ﺁﻥ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ ﺑﻪ ﻧﺎﻡ ﺭﻭﺵ ﺍﻧﺸﻌﺎﺏ ﻭ ﺗﺤﺪﻳﺪ ﻳﺎ ﺷﺎﺧﻪ ﻭ ﺣﺪ ﻣﻌـﺮﻭﻑ ﺍﺳـﺖ‪ .‬ﺍﻳـﻦ‬
‫ﺭﻭﺵ ﻳﻚ ﺭﻭﺵ ﻏﻴﺮﻫﺪﻓﻤﻨﺪ ﻭﻟﻲ ﻫﻮﺷﻤﻨﺪ ﺍﺳﺖ‪ .‬ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑـﺮﺧﻼﻑ ﺭﻭﺵ ﻋﻘﺒﮕـﺮﺩ ﺗﻤـﺎﻣﻲ ﺣـﺎﻻﺕ ﺩﺭ ﻓﻀـﺎﯼ‬
‫ﺣﺎﻟﺖ ﺑﺮﺭﺳﯽ ﻧﻤﻲﺷﻮﺩ ﻭ ﺑﺮﺍﺳﺎﺱ ﺷﺮﻃﻲ ﻛﻪ ﺩﺭ ﻣﺴﺌﻠﻪ ﻗﺮﺍﺭ ﺩﺍﺩﻩ ﻣﻲﺷﻮﺩ )ﺍﻳﻦ ﺷﺮﻭﻁ ﻭﺍﺑﺴﺘﻪ ﺑﻪ ﻧﻮﻉ ﻣﺴـﺌﻠﻪ ﻣﺘﻔـﺎﻭﺕ‬
‫ﺍﺳﺖ( ﺑﺮﺧﻲ ﺍﺯ ﺣﺎﻟﺖﻫﺎ ﺑﺮﺭﺳﻲ ﻧﻤﻲﺷﻮﻧﺪ‪.‬‬
‫ﺳﻪ ﺗﻔﺎﻭﺕ ﻋﻤﺪﻩ ﺑﻴﻦ ﺭﻭﺵ ﻏﻘﺒﮕﺮﺩ ﻭ ﺭﻭﺵ ﺷﺎﺧﻪ ﻭ ﺣﺪ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪:‬‬
‫‪ -۱‬ﺩﺭ ﺭﻭﺵ ﻋﻘﺒﮕﺮﺩ ﺩﺭﺧﺖ ﻓﻀﺎﯼ ﺣﺎﻟﺖ ﺑﺼﻮﺭﺕ ﻋﻤﻖ ﺍﻭﻝ )‪ (DFS‬ﺟﺴﺘﺠﻮ ﻣﻴﺸﻮﺩ ﻭﻟﯽ ﺩﺭ ﺭﻭﺵ ﺷﺎﺧﻪ ﻭ‬
‫ﺣﺪ ﺍﺑﺘﺪﺍ ﮐﻠﻴﻪ ﻓﺮﺯﻧﺪﺍﻥ ﮔﺮﻩ ﻓﻌﻠﯽ ﺳﺎﺧﺘﻪ ﻣﻴﺸﻮﺩ ﻭ ﺳﭙﺲ ﺍﺯ ﺑﻴﻦ ﺁﻧﻬﺎ ﻳﮑﯽ ﺑﺴﺘﻪ ﺑﻪ ﺷﺮﺍﻳﻂ ﺍﻧﺘﺨﺎﺏ ﻣﻴﺸﻮﺩ ﻭﺗﺎ‬
‫ﺣﺪﻭﺩﯼ ﻣﻴﺘﻮﺍﻥ ﺁﻥ ﺭﺍ ﻣﻨﻄﺒﻖ ﺑﺎ ﺟﺴﺘﺠﻮﯼ ﺭﺩﻳﻔﯽ )‪ (BFS‬ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ‪.‬‬
‫‪ -۲‬ﺩﺭ ﺭﻭﺵ ﺷﺎﺧﻪ ﻭ ﺣﺪ ﻳﮏ ﺗﺎﺑﻊ ﻣﺤﺪﻭﺩ ﮐﻨﻨﺪﻩ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﺍﺯ ﮔﺴﺘﺮﺵ ﺑﻴﺶ ﺍﺯ ﺣﺪ ﻭ ﻧﺎﺑﺠﺎﯼ ﺷﺎﺧﻪ ﻫـﺎﯼ‬
‫ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ ﺟﻠﻮﮔﻴﺮﯼ ﻣﻴﮑﻨﺪ ﻭ ﺩﺭ ﻣﻮﻗﻊ ﻟﺰﻭﻡ ﺷﺎﺧﻪ ﻫﺎ ﺭﺍ ﻗﻄﻊ ﮐـﺮﺩﻩ ﻭ ﻣﺴـﻴﺮ ﻓﻌﻠـﯽ ﺭﺍ ﺍﺩﺍﻣـﻪ ﻧﻤـﯽ‬
‫ﺩﻫﺪ‪ .‬ﺩﺭﺣﺎﻟﻴﮑﻪ ﺩﺭ ﺭﻭﺵ ﻋﻘﺒﮕﺮﺩ ﭼﻨﻴﻦ ﻣﻌﻴﺎﺭﯼ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ‪.‬‬
‫‪ -۳‬ﺭﻭﺵ ﺷﺎﺥ ﻭ ﺣﺪ ﺩﺭ ﻣﻘﺎﻳﺴﻪ ﺑﺎ ﺭﻭﺵ ﻋﻘﺒﮕﺮﺩ ﻫﻮﺷﻤﻨﺪﺍﻧﻪ ﺗﺮ ﻋﻤﻞ ﻣﻴﮑﻨﺪ ﻭ ﺩﺭ ﻫﻨﮕﺎﻡ ﺍﻧﺘﺨﺎﺏ ﺷﺎﺧﻪ ﺟﻬـﺖ‬
‫ﮔﺴﺘﺮﺵ ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ‪ ،‬ﺷﺎﺧﻪﺍﯼ ﮐﻪ ﺍﺣﺘﻤﺎﻝ ﺑﻴﺸﺘﺮﯼ ﺑﺮﺍﯼ ﺗﻮﻟﻴﺪ ﺟﻮﺍﺏ ﺩﺍﺭﺩ ﺍﻧﺘﺨﺎﺏ ﻣﻲﺷﻮﺩ‪.‬‬
‫ﺣﺎﻝ ﺑﻪ ﺍﺭﺍﺋﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﻳﻲ ﻣﺒﺘﻨﯽ ﺑﺮ ﺍﻳﻦ ﺭﻭﺵ ﻣﻲﭘﺮﺩﺍﺯﻳﻢ‪.‬‬

‫‪١‬‬ ‫‪٧‬‬

‫ﺩ‬ ‫ﺮ‬ ‫ﻩ‬ ‫ﺭ‬ ‫ﻭ‬ ‫ﺩ‬ ‫ﻩ‬ ‫ﺷ‬ ‫ﻭ‬ ‫ﺮ‬ ‫ﻓ‬

‫‪-‬‬ ‫‪-‬‬

‫ﮔ‬ ‫ﺪ‬ ‫ﻨ‬

‫ﺩﺭ ﺍﻳﻦ ﺑﺨﺶ ﺑﻪ ﺍﺭﺍﺋﻪ ﺭﻭﺷﯽ ﻣﺒﻨﺘﯽ ﺑﺮ ﺷﺎﺧﻪ ﻭ ﺣﺪ ﺑﺮﺍﯼ ﻣﺴﺌﻠﻪ ﻓﺮﻭﺷﻨﺪﻩ ﺩﻭﺭﻩ ﮔﺮﺩ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪.‬‬

‫ﺍﺳﺖ ﻭ ﺩﺭ ﻳـﻚ ﮔـﺮﺍﻑ ﻏﻴﺮﺟﻬـﺖﺩﺍﺭ ﺗﻌـﺪﺍﺩ ﺩﻭﺭﻫـﺎﻱ‬

‫ﺩﺭ ﻳﻚ ﮔﺮﺍﻑ ﺟﻬﺖﺩﺍﺭ ﺗﻌﺪﺍﺩ ﺩﻭﺭﻫﺎﻱ ﻫﺎﻣﻴﻠﺘﻮﻧﻲ !)‪( n − 1‬‬
‫!)‪( n − 1‬‬
‫ﺍﺳﺖ!‪.‬‬ ‫‪2‬‬ ‫ﻫﺎﻣﻴﻠﺘﻮﻧﻲ‬
 ‫‪٧٨‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫ﻣﺜﺎﻝ‪ :‬ﭘﻴﺪﺍ ﻛﺮﺩﻥ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﻲ ﺩﺭ ﻳﻚ ﮔﺮﺍﻑ ﺑﺎ ‪ ٥‬ﺭﺃﺱ‬

‫‪3‬‬
‫‪3‬‬
‫‪a‬‬ ‫‪b‬‬

‫‪7‬‬ ‫‪4‬‬
‫‪4‬‬

‫‪8‬‬
‫‪6‬‬
‫‪e‬‬ ‫‪c‬‬
‫‪2‬‬ ‫‪6‬‬ ‫‪5‬‬
‫‪d‬‬

‫ﺗﺎﺑﻊ ﻣﺤﺪﻭﺩ ﮐﻨﻨﺪﻩ‪:‬‬

‫‪1‬‬
‫= ) ‪f (G‬‬ ‫}‪∑{c(u, v) + c(v, w) : (u, v) , (v, w) are two least cos t edges adjacent to vertex v‬‬
‫‪2 v∈V‬‬

‫ﻭﺍﺿﺢ ﺍﺳﺖ ﮐﻪ ﻣﻘﺪﺍﺭ ﺗﺎﺑﻊ ﺑﺎﻻ ﺩﺭ ﮔﺮﺍﻑ ‪ ،G‬ﺣﺪ ﭘﺎﻳﻴﻨﯽ ﺑﺮﺍﯼ ﻫﺰﻳﻨﻪ ﺩﻭﺭﻫﺎﯼ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ ﺧﻮﺍﻫﺪ ﺑـﻮﺩ ﭼـﻮﻥ ﺑـﺮﺍﯼ ﻫـﺮ‬
‫ﺭﺍﺱ ﺩﻭ ﻳﺎﻝ ﺑﺎ ﮐﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﮐﻪ ﻣﺠﺎﻭﺭ ﺑﻪ ﺁﻥ ﺭﺍﺱ ﻫﺴﺘﻨﺪ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﮐﺮﺩﻩ ﺍﺳﺖ‪ .‬ﻟﺬﺍ ﺩﺭ ﮔﺴﺘﺮﺵ ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ‬
‫ﻫﺮ ﺩﻭﺭﯼ ﮐﻪ ﻫﺰﻳﻨﻪ ﺁﻥ ﺑﻪ ﻣﻘﺪﺍﺭ ﺗﺎﺑﻊ ﺑﺎﻻ ﻧﺰﺩﻳﮑﺘﺮ ﺑﻮﺩ ﺯﻭﺩﺗﺮ ﺟﻬﺖ ﮔﺴﺘﺮﺵ ﺍﻧﺘﺨﺎﺏ ﻣﻴﺸﻮﺩ‪.‬‬
 ‫‪٧٩‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫ﺩﺭﺧﺖ ﻓﻀﺎﯼ ﺣﺎﻻﺕ ﺑﺮﺍﯼ ﮔﺮﺍﻓﯽ ﺑﺎ ‪ ٥‬ﺭﺃﺱ ﺩﺭ ﺣﺎﻟﺖ ﻛﻠﻲ ﺑﻪ ﺷﻜﻞ ﺯﻳﺮ ﻣﻲﺑﺎﺷﺪ‪:‬‬

‫ه‬ ‫ر‬ ‫و‬ ‫د‬ ‫‬ ‫‬ ‫‬ ‫‬

‫‪ab‬‬
‫‪ab‬‬

‫‪ac‬‬ ‫‪ac‬‬ ‫‪ac‬‬ ‫‪ac‬‬

‫‪abedc‬‬ ‫‪abedc‬‬ ‫‪ad‬‬ ‫‪ad‬‬ ‫‪ad‬‬

‫‪ad‬‬
‫‪abced‬‬ ‫‪abecd‬‬

‫ﻭﺍﺿﺢ ﺍﺳﺖ ﮐﻪ ﻭﻗﺘﯽ ‪ ab‬ﻭ ‪ ac‬ﺩﺭ‬

‫ﺩﻭﺭ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﺑﻪ ﺩﻟﻴﻞ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ‬ ‫‪abcde‬‬ ‫‪abdce‬‬
‫ﺑــــﻮﺩﻥ ﺩﻭﺭ ﻳﺎﻟﻬــــﺎﯼ ‪ ad‬ﻭ ‪ae‬‬
‫ﻧﻤﻴﺘﻮﺍﻧﻨﺪ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻨﺪ‬

‫‪acbde‬‬ ‫‪acdbe‬‬ ‫‪acbed‬‬ ‫‪acebd‬‬

‫‪adbce‬‬

‫‪adcbe‬‬

‫ﺗﻮﺿﻴﺢ‪:‬‬
‫ﺩﺭﻳﻚ ﮔﺮﺍﻑ ﺑﺮﺍﻱ ﻫﺮ ﺭﺃﺱ ‪ ٢‬ﻳﺎﻝ ﺑﺎ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺭﺍ ﺍﻧﺘﺨﺎﺏ ﻣﻲﻛﻨﻴﻢ ﻣﺠﻤﻮﻉ ﻫﺰﻳﻨﻪﻫﺎ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﺮﺩﻩ ﺳـﭙﺲ ﺑـﺮﺩﻭ‬
‫ﺗﻘﺴﻴﻢ ﻣﻲﻛﻨﻴﻢ ﺗﺎ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪﺍﻱ ﻛﻪ ﻣﻤﻜﻦ ﺍﺳﺖ ﺑﺪﺳﺖ ﺁﻳﺪ‪.‬‬
‫ﺍﻭﻟــﻴﻦ ﺩﻭﻣﻴﻦ‬ ‫ﺭﺍﺱ‬
‫ﻣﻴﻨﻴﻤﻢ‬ ‫ﻣﻴﻨﻴﻤﻢ‬
‫‪3‬‬ ‫‪2‬‬ ‫‪a‬‬
‫‪3‬‬ ‫‪3‬‬ ‫‪b‬‬
‫‪4‬‬ ‫‪4‬‬ ‫‪c‬‬
‫‪5‬‬ ‫‪2‬‬ ‫‪d‬‬
‫‪6‬‬ ‫‪3‬‬ ‫‪e‬‬
‫‪35 / 2 = 17 / 5‬‬
 ‫‪٨٠‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫ﭼﻮﻥ ﺷﺎﺧﻪ ﺳﻤﺖ ﭼﭗ ﺩﺍﺭﺍﯼ ﻣﻘﺪﺍﺭ ﮐﻤﺘـﺮﯼ‬

‫ﺳﺖ ﺁﻥ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‬
‫‪17.5‬‬

‫‪17.5, ab‬‬ ‫‪18.5, ab‬‬

‫‪ab , ac , ad , ae‬‬ ‫‪ab , ac , ad , ae‬‬

‫‪ac , ab‬‬ ‫‪18.5‬‬
‫‪20.5‬‬ ‫‪18,ac‬‬ ‫‪21‬‬

‫ﭼﻮﻥ ﺷﺎﺧﻪ ﺳـﻤﺖ ﺭﺍﺳـﺖ ﺩﺍﺭﺍﯼ ﻣﻘـﺪﺍﺭ‬

‫ﮐﻤﺘﺮﯼ ﺍﺳﺖ ﺁﻥ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‬
‫‪ab , ac , ae , ad‬‬
‫‪18‬‬ ‫‪ab , ac , ad , ae‬‬
‫‪23‬‬
‫‪ac , ab , ad , ae‬‬ ‫‪ac , ab , ad , ae‬‬
‫‪18.5‬‬ ‫‪23.5‬‬
‫‪abecd,21‬‬ ‫‪abced,23‬‬

‫ﭼﻮﻥ ﺷﺎﺧﻪ ﺳﻤﺖ ﭼﭗ ﺩﺍﺭﺍﯼ ﻣﻘﺪﺍﺭ ﮐﻤﺘـﺮﯼ‬ ‫‪acebd,23‬‬

‫ﺳﺖ ﺁﻥ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ‪ .‬ﺑﻌﺪ ﺍﺯ ﺗﻮﻟﻴﺪ ﺟﻮﺍﺏ‬
‫ﺑـﺎ ﻣﻘـﺪﺍﺭ ‪ ۲۱‬ﮐﻠﻴـﻪ ﺷـﺎﺧﻪ ﻫـﺎﯼ ﺑﺰﺭﮔﺘـﺮ ﻳـﺎ‬
‫ﻣﺴﺎﻭﯼ ﺑﺎ ﺁﻥ ﻗﻄﻊ ﺷﺪﻩ ﻭ ﺷﺎﺧﻪ ﻫـﺎﻳﻲ ﮐـﻪ ﺍﺯ‬
‫ﺁﻥ ﮐﻤﺘﺮ ﻫﺴﺘﻨﺪ ﺭﺍ ﺑﻪ ﺍﻣﻴﺪ ﺟﻮﺍﺏ ﮐﻤﺘﺮ ﺍﺩﺍﻣـﻪ‬
‫ﻣﻴﺪﻫﻴﻢ‬
‫‪acbed,19‬‬
‫ﺑﻪ ﻋﻠﺖ ﻭﺟﻮﺩ ﺟﻮﺍﺏ ﻣﻮﻗﺘﯽ ‪ ۲۱‬ﺷﺎﺧﻪ ﻗﻄـﻊ‬
‫ﻣﻴﺸﻮﺩ‬
‫ﭼﻮﻥ ﺍﺯ ‪ ۲۱‬ﮐﻤﺘﺮ ﺍﺳﺖ ﻗﺒﻮﻝ ﻣﻴﮕﺮﺩﺩ ﻭ ﺍﮔﺮ‬
‫ﺷﺎﺧﻪ ﺍﯼ ﮐﻤﺘﺮ ﺍﺯ ﺁﻥ ﻭﺟﻮﺩ ﺩﺍﺷﺖ ﺑﺎﻳﺪ‬
‫ﺩﺍﻣﻪ ﻣﻲﻳﺎﻓﺖ ﻭ ﭼﻮﻥ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ﺟﻮﺍﺏ‬
‫ﻧﻬﺎﻳﻲ ‪ ۱۹‬ﺍﺳﺖ‬

‫ﻃﺮﻳﻘﻪ ﻣﺤﺎﺳﺒﻪ ﺍﺭﺯﺵ ﻫﺮﮔﺮﻩ‪:‬‬

‫ﺑﺮ ﺍﺳﺎﺱ ﺗﺎﺑﻊ ﻣﺤﺪﻭﺩ ﮐﻨﻨﺪﻩ ﮐﻪ ﺩﺭ ﺑﺎﻻ ﺷﺮﺡ ﺩﺍﺩﻩ ﺷﺪ ﺑﺎﻳﺪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻣﺤﺪﻭﺩﻳﺘﻬﺎﯼ ﻫﺮ ﻣﺴﻴﺮ ﺍﺯ ﺭﻳﺸﻪ ﺗﺎ ﺁﻥ ﮔـﺮﻩ ﺗـﺎﺑﻊ‬
‫ﺭﺍ ﻣﺠﺪﺩﺍﹰ ﻣﺤﺎﺳﺒﻪ ﮐﺮﺩ‪ .‬ﺑﻪ ﺑﻴﺎﻥ ﺩﻳﮕﺮ ﺑﺎ ﺍﺿﺎﻓﻪ ﺷﺪﻥ ﺷﺮﺍﻳﻂ ﺟﺪﻳﺪ ﻣﻘﺪﺍﺭ ﺗﺎﺑﻊ ﺑﻴﺸﺘﺮ ﻳﺎ ﻣﺴﺎﻭﯼ ﻣﻘﺪﺍﺭ ﮔﺮﻩ ﭘـﺪﺭ ﺧﻮﺍﻫـﺪ‬
‫ﺑﻮﺩ‪.‬‬
‫ﻭﻗﺘﻲ ﺍﻳﻦ ﺭﻭﻳﻪ ﺭﺍ ﺗﺎ ﺍﻧﺘﻬﺎ ﺍﺩﺍﻣﻪ ﺩﻫﻴﻢ ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﻲ ﺑﺎ ﻛﻤﺘﺮﻳﻦ ﻫﺰﻳﻨﻪ ﺑﺪﺳﺖ ﻣﻲﺁﻳﺪ ﻭﻟﻲ ﺑﺮﺍﻱ ﻫﻮﺷﻤﻨﺪ ﺷﺪﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ‬
‫ﻛﻞ ﻓﻀﺎﯼ ﺣﺎﻻﺕ ﺭﺍ ﭘﻮﻳﺶ ﻧﻤﻲﻛﻨﻴﻢ ﺑﻠﮑﻪ ﺍﺯ ﺑﻴﻦ ﻧﻮﺩﻫﺎﻳﻲ ﻛﻪ ﺩﺍﺭﻳﻢ ﻧﻮﺩﻱ ﺭﺍ ﻛﻪ ﺩﺍﺭﺍﻳﯽ ﺗﻔﺎﻭﺕ ﮐﻤﺘﺮﯼ ﺗﺎ ﮔـﺮﻩ ﺭﻳﺸـﻪ‬
‫ﺍﺳﺖ ﺭﺍ ﮔﺴﺘﺮﺵ ﻣﻴﺪﻫﻴﻢ ﺗﺎ ﺑﻪ ﺑﺮﮒ ﺑﺮﺳﻴﻢ‪ ،‬ﺩﺭ ﻫﺮ ﻣﺮﺣﻠﻪ ﮐﻮﭼﮑﺘﺮﻳﻦ ﮔﺮﻩ ﺭﺍ ﺍﺩﺍﻣﻪ ﻣﻴﺪﻫﻴﻢ ﻭ ﺑﺎ ﺭﺳﻴﺪﻥ ﺑـﻪ ﻳـﮏ ﺑـﺮﮒ‬
‫)ﺟﻮﺍﺏ ﻣﻮﻗﺘﯽ( ﮐﻠﻴﻪ ﮔﺮﻩ ﻫﺎﯼ ﺑﻴﺸﺘﺮ ﻳﺎ ﻣﺴﺎﻭﯼ ﺁﻥ ﺭﺍ ﻗﻄﻊ ﻣﻴﮑﻨﻴﻢ‪.‬‬
‫‪٨١‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫ﻧﻜﺘﻪ‪ :‬ﺍﻟﮕﻮﺭﻳﺘﻢﻫﺎﻱ ‪ Branch & Bound‬ﺍﺯ ﻟﺤﺎﻅ ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺗﻔﺎﻭﺗﻲ ﺑﺎ ﺍﻟﮕﻮﺭﻳﺘﻢﻫﺎﻱ ‪ Backtraking‬ﻧﺪﺍﺭﻧﺪ ﻭﻟﯽ‬
‫ﺍﺯ ﺯﻣﺎﻥ ﻭﺍﻗﻌﯽ ﮐﻤﺘﺮﯼ ﺑﺮﺧﻮﺭﺩﺍﺭﻧﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﺩﺭ ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ ﺑﺎﻻ ﻓﻘﻂ ‪ ۴‬ﺩﻭﺭ ﻣﺨﺘﻠﻒ ﻣﺤﺎﺳﺒﻪ ﺷﺪﻧﺪ ﺩﺭﺣﺎﻟﯽ ﮐﻪ ﺩﺭ ﺭﻭﺵ ﻋﻘﺒﮕـﺮﺩ ﺑﺎﻳـﺪ ﺗﻤـﺎﻡ ‪ ۱۲‬ﺩﻭﺭ‬
‫ﻣﺨﺘﻠﻒ ﺭﺍ ﺗﻮﻟﻴﺪ ﻣﻴﮑﺮﺩﻳﻢ‪.‬‬

‫ﻪ‬ ‫ﻪ‬
‫‪٢‬‬ ‫‪٧‬‬

‫ﻮ‬ ‫ﺠ‬ ‫ﻣ‬ ‫ﻚ‬ ‫ﻳ‬ ‫ﻱ‬ ‫ﺎ‬ ‫ﻫ‬ ‫ﻮ‬ ‫ﺠ‬ ‫ﻣ‬ ‫ﺮ‬ ‫ﻳ‬ ‫ﺯ‬ ‫ﻊ‬ ‫ﺟ‬

‫‪-‬‬ ‫‪-‬‬
‫ﻤ‬ ‫ﻤ‬ ‫ﻤ‬

‫ﻋ‬ ‫ﻋ‬

‫ﺣﺎﻝ ﺑﻪ ﺑﻴﺎﻥ ﻣﺴﺌﻠﻪ ﺩﻳﮕﺮﯼ ﮐﻪ ﺗﻮﺳﻂ ﺭﻭﺵ ﺷﺎﺧﻪ ﻭ ﺣﺪ ﻣﻴﺘﻮﺍﻥ ﺑﺮﺍﯼ ﺁﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺟﺎﻟﺒﯽ ﺍﺭﺍﺋﻪ ﮐﺮﺩ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪ .‬ﺩﺭ ﺍﻳـﻦ‬
‫ﻣﺴﺌﻠﻪ ﻫﺪﻑ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﺯﻳﺮ ﻣﺠﻤﻮﻋﻪﺍﯼ ﺍﺯ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ﻣﻔﺮﻭﺽ ﺍﺳﺖ ﮐﻪ ﻣﺠﻤﻮﻉ ﻫﻌﻀﺎﯼ ﺁﻥ ﻣﻘﺪﺍﺭ ﻣﺸﺨﺼﯽ ﺑﺎﺷﺪ‪.‬‬
‫ﻭﺭﻭﺩﯼ‪:‬‬
‫ﻣﺠﻤﻮﻋﻪ }‪S={s1, s2, ..., sn‬‬
‫ﻋﺪﺩ ﻣﻔﺮﻭﺽ ‪M‬‬

‫ﺧﺮﻭﺟﻲ‪:‬‬
‫}‪X={x1, x2, ..., xn‬‬
‫)‪ 1 (1≤ i ≤ n‬ﻳﺎ ‪xi = 0‬‬
‫‪n‬‬

‫‪∑ x .s‬‬
‫‪i =1‬‬
‫‪i‬‬ ‫‪i‬‬ ‫‪=M‬‬

‫ﻓﺮﺽ‪ :‬ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ‪ S‬ﺻﻌﻮﺩﻱ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺗﺎﺑﻊ ﻣﺤﺪﻭﺩ ﮐﻨﻨﺪﻩ‪:‬‬

‫ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳﻪ ‪ X‬ﺍﻧﺘﺨﺎﺏ ﻳﺎ ﻋﺪﻡ ﺍﻧﺘﺨﺎﺏ ﻋﻨﺎﺻﺮ ﻣﺘﻨﺎﻇﺮ ﺩﺭ ‪ S‬ﺭﺍ ﻧﺸﺎﻥ ﻣﻴﺪﻫﻨﺪ‪ .‬ﻓﺮﺽ ﮐﻨﻴﺪ ﮐﻪ ﻋﻨﺎﺻﺮ ﺁﺭﺍﻳـﻪ ‪ X‬ﺗـﺎ ‪k-1‬‬
‫ﺍﻣﻴﻦ ﻋﻨﺼﺮ ﻳﻌﻨﯽ ‪ xk-1‬ﻣﺸﺨﺺ ﺷﺪﻩ ﺍﻧﺪ ﻭ ﻧﻮﺑﺖ ﺑﻪ ﻣﺸﺨﺺ ﺷﺪﻥ ‪ k‬ﺍﻣﻴﻦ ﻋﻀﻮ ﺍﺯ ‪ X‬ﻳﻌﻨﯽ ‪ xk‬ﺭﺳـﻴﺪﻩ ﺍﺳـﺖ‪ .‬ﺑﺎﻳـﺪ‬
‫ﺷﺮﺍﻳﻂ ﺯﻳﺮ ﺑﺮﻗﺮﺍﺭ ﺑﺎﺷﻨﺪ‪ .‬ﺑﻪ ﺑﻴﺎﻥ ﺩﻳﮕﺮ ﺍﮔﺮ ﺩﺭ ﺷﺎﺧﻪﺍﯼ ﺷﺮﺍﻳﻂ ﺯﻳﺮ ﺑﺮﻗﺮﺍﺭ ﻧﺒﻮﺩ ﺁﻥ ﺷﺎﺧﻪ ﺑﻪ ﺟﻮﺍﺏ ﻣﻨﺠﺮ ﻧﺨﻮﺍﻫﺪ ﺷـﺪ‬
‫ﻭ ﺑﺎﻳﺪ ﺷﺎﺧﻪ ﻗﻄﻊ ﺷﻮﺩ‪.‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪… k-1 k‬‬ ‫‪n‬‬

‫‪x1 x2 … xk-1‬‬
‫‪٨٢‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫‪k −1‬‬

‫‪∑ x .s‬‬
‫‪i =1‬‬
‫‪i‬‬ ‫‪i‬‬ ‫‪+ sk ≤ M‬‬ ‫‪) -۱‬ﺑﻪ ﺩﻟﻴﻞ ﺻﻌﻮﺩﯼ ﺑﻮﺩﻥ ﻋﻨﺎﺻﺮ ‪(S‬‬
‫‪k −1‬‬ ‫‪n‬‬

‫‪∑ xi .si + ∑ si ≥ M -۲‬‬

‫‪i =1‬‬ ‫‪i =k‬‬

‫ﺗﻮﺿﻴﺢ‪:‬‬
‫ﺷﺮﻁ ‪ :۱‬ﺑﻴﺎﻥ ﻛﻨﻨﺪﻩ ﺍﻳﻦ ﻣﻄﻠﺐ ﻣﻲﺑﺎﺷﺪ ﻛﻪ ﺍﮔﺮ ﻣﺠﻤﻮﻉ ﻭﺯﻥ ﻋﻨﺎﺻﺮﯼ ﻛﻪ ﺗﺎﻛﻨﻮﻥ ﺍﻧﺘﺨﺎﺏ ﺷـﺪﻩﺍﻧـﺪ ﺑـﻪ ﺍﺿـﺎﻓﻪﺍﻱ ﻭﺯﻥ‬
‫ﻋﻨﺼﺮ ﺑﻌﺪﻱ‪ ،‬ﺍﺯ ‪ M‬ﺑﻴﺸﺘﺮ ﺷﻮﺩ ﭼﻮﻥ ﻋﻨﺎﺻﺮ ﺻﻌﻮﺩﻱ ﻫﺴﺘﻨﺪ ﻭﺯﻥ ﻋﻨﺎﺻﺮ ﺑﻌﺪﻱ ﺍﺯ ﻋﻨﺼﺮ ‪ k‬ﺑﻴﺸـﺘﺮ ﺍﺳـﺖ ﭘـﺲ ﺍﺩﺍﻣـﻪ‬
‫ﻧﻤﻲﺩﻫﻴﻢ‪.‬‬
‫ﺷﺮﻁ ‪ :۲‬ﺑﻴﺎﻥ ﻛﻨﻨﺪﻩ ﺍﻳﻦ ﻣﻄﻠﺐ ﻣﻲﺑﺎﺷﺪ ﻛﻪ ﺍﮔﺮ ﻣﺠﻤﻮﻉ ﻭﺯﻥ ﻋﻨﺎﺻﺮﻱ ﻛﻪ ﺗﺎﻛﻨﻮﻥ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩﺍﻧﺪ ﺑﻪ ﺍﺿﺎﻓﻪﺍﻱ ﻭﺯﻥ ﻛﻞ‬
‫ﻋﻨﺎﺻﺮ ﺑﺎﻗﻲ ﻣﺎﻧﺪﻩ ﻛﻤﺘﺮ ﺍﺯ ﻣﻘﺪﺍﺭ‪ M‬ﺑﺎﺷﺪ ﺍﮔﺮ ﺗﻤﺎﻡ ﻋﻨﺎﺻﺮ ﺍﻧﺘﺨﺎﺏ ﻛﻨﻴﻢ ﺑﻪ ﻣﻘﺪﺍﺭ ‪ M‬ﻧﻤﻲﺭﺳﻴﻢ ﭘﺲ ﺍﺩﺍﻣﻪ ﻧﻤﻲﺩﻫﻴﻢ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫}‪S = {7,10,12,13,15,18‬‬
‫‪M=30‬‬
‫‪n=6‬‬
‫‪ :S‬ﻣﺠﻤﻮﻉ ﻭﺯﻥ ﻋﻨﺎﺻﺮ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﺗﺎ ﺑﻪ ﺣﺎﻝ‬
‫‪ :K‬ﻋﻨﺼﺮﯼ ﮐﻪ ﺭﻭﯼ ﺁﻥ ﺩﺭ ﺣﺎﻝ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﻫﺴﺘﻴﻢ‬
‫‪ :r‬ﻣﺠﻤﻮﻉ ﻫﺰﻳﻨﻪﻫﺎﻱ ﺍﺯ ﺭﺃﺱ ‪ k‬ﺑﻪ ﺑﻌﺪ‬
 ‫‪٨٣‬‬ ‫)‪(Branch & Bound‬‬
‫
‬ ‫و‬ ‫ب‬ ‫‬ ‫‬ ‫ ‬ ‫ا‬ ‫ش‬ ‫و‬ ‫ر‬

‫
‬

‫ﻧﮑﺘﻪ‪ :‬ﻫﺮ ﮔﺮﻩ ﺍﺯ ﺩﺭﺧﺖ ﺣﻞ ﻣﺴﺌﻠﻪ ﺭﺍ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﻓﺮﺽ ﻣﻴﮑﻨﻴﻢ‪:‬‬

‫‪s‬‬ ‫‪k‬‬ ‫‪r‬‬

‫‪k −1‬‬ ‫‪n‬‬

‫‪s = ∑ s i . xi‬‬ ‫‪r = ∑ si‬‬
‫‪i =1‬‬ ‫‪i=k‬‬

‫‪٠‬‬ ‫‪١‬‬ ‫‪٧‬‬

‫‪x1= 1‬‬ ‫‪0‬‬

‫‪٧‬‬ ‫‪٢‬‬ ‫‪٨‬‬

‫‪x2=1‬‬ ‫‪٠‬‬ ‫‪٢‬‬ ‫‪٨‬‬
‫‪0‬‬
‫‪١٧‬‬ ‫‪٣‬‬ ‫‪٨‬‬ ‫‪٧‬‬ ‫‪٣‬‬ ‫‪٨‬‬

‫‪x3=1‬‬ ‫‪0‬‬

‫ﺩﺭ ﺻﻮﺭﺕ ﻧﻴﺎﺯ ﺑﻪ ﺑﻘﻴﻪ ﺟﻮﺍﺑﻬﺎ‬

‫‪٢٩‬‬ ‫‪T‬‬ ‫‪T‬‬ ‫‪١٧‬‬ ‫‪T‬‬ ‫‪T‬‬
‫ﺍﻳﻦ ﺷﺎﺧﻪ ﻫﺎ ﻧﻴﺰ ﺑﺎﻳـﺪ ﺍﺩﺍﻣـﻪ‬
‫ﺩﺍﺩﻩ ﺷﻮﻧﺪ‬
‫‪x4 =1‬‬ ‫‪0‬‬

‫‪١٧‬‬ ‫‬ ‫‪٣٣‬‬

‫‪٣٠‬‬ ‫‬ ‫‪٣٣‬‬

‫ﺑﻪ ﺩﻟﻴﻞ ﻋﺪﻡ ﺍﻧﻄﺒﺎﻕ ﺑﺎ ﺷـﺮﻁ‬

‫ﺍﻭﻝ ﺷﺎﺧﻪ ﻗﻄﻊ ﻣﻴﺸﻮﺩ‬

‫ﺑﻪ ﺩﻟﻴﻞ ﻋﺪﻡ ﺍﻧﻄﺒﺎﻕ ﺑﺎ ﺷـﺮﻁ‬

‫ﻳﮏ ﺟﻮﺍﺏ ﻣﺤﺴﻮﺏ ﻣﻴﺸﻮﺩ‬
‫ﺍﻭﻝ ﺷﺎﺧﻪ ﻗﻄﻊ ﻣﻴﺸﻮﺩ‬
‫)‪X=(1,1,0,1,0,0‬‬

‫ﻧﮑﺘﻪ‪ :‬ﻋﺪﺩ ﻳﮏ ﺩﺭ ﺷﺎﺧﻪ ﻫﺎ ﻧﺸﺎﻥﺩﻫﻨﺪﻩ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻥ ﻋﻨﺼﺮ ﻭ ﻋﺪﺩ ﺻﻔﺮ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ ﺍﻧﺘﺨﺎﺏ ﻧﺸﺪﻥ ﻋﻨﺼﺮ ﻣﻴﺒﺎﺷﺪ‪.‬‬
‫ﻧﮑﺘﻪ‪ :‬ﻣﺮﺗﺒﻪ ﺯﻣﺎﻧﯽ ﺍﻟﮕﻮﺭﻳﺘﻢ )‪ O(2n‬ﻣﻴﺒﺎﺷﺪ!‪.‬‬
 ‫‪۸‬‬

‫ﺪ‬

‫ﺕ‬

‫ﻣ‬ ‫ﯽ‬

‫ﺎ‬ ‫ﺒ‬ ‫ﺳ‬ ‫ﺎ‬ ‫ﺤ‬ ‫ﮔ‬ ‫ﻴ‬ ‫ﭽ‬ ‫ﻴ‬ ‫ﭘ‬ ‫‪-‬‬

‫ﺩﺭ ﺍﻳﻦ ﺑﺨﺶ ﺑﻪ ﺩﺳﺘﻪ ﺑﻨﺪﯼ ﻣﺴﺎﺋﻞ ﺍﺯ ﻟﺤﺎﻅ ﺳﺎﺩﮔﯽ ﻭ ﺳﺨﺘﯽ ﻣﻴﭙﺮﺩﺍﺯﻳﻢ‪ .‬ﺍﺑﺘﺪﺍ ﭼﻨﺪ ﺗﻌﺮﻳﻒ ﺍﺭﺍﺋﻪ ﻣﻴﺪﻫﻴﻢ‪:‬‬
‫ﻣﺴﺎﺋﻞ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ‪ :‬ﻣﺴﺎﺋﻠﯽ ﮐﻪ ﺧﺮﻭﺟﯽ ﺁﻧﻬﺎ ﺩﺍﺭﺍﯼ ﺩﻭ ﺣﺎﻟﺖ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﮔﺮﺍﻑ ﻭﺯﻥ ﺩﺍﺭﯼ ﻣﻔﺮﻭﺽ ﺍﺳﺖ‪ .‬ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﺁﻳﺎ ﻫﺰﻳﻨﻪ ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ ﻣﻴﻨﻴﻤﻢ ﺍﻳﻦ ﮔـﺮﺍﻑ ﺍﺯ ﻣﻘـﺪﺍﺭ ‪ k‬ﮐﻤﺘـﺮ‬
‫ﺍﺳﺖ ﻳﺎ ﺧﻴﺮ ﻳﮏ ﻣﺴﺌﻠﻪ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﻣﺤﺴﻮﺏ ﻣﻴﺸﻮﺩ‪.‬‬
‫ﻛﻼﺱ‪ :P‬ﻣﺠﻤﻮﻋﻪ ﻣﺴﺎﺋﻞ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﻛﻪ ﺑﺮﺍﻱ ﺁﻧﻬﺎ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻗﻄﻌﻲ ﺑﺎ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠﻪﺍﻱ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬
‫ﻛﻼﺱ‪ :NP‬ﻣﺠﻤﻮﻋﻪ ﻣﺴﺎﺋﻞ ﺗﺼﻤﻴﻢ ﮔﻴﺮﯼ ﻛﻪ ﺑﺮﺍﻱ ﺁﻧﻬﺎ ﻳﻚ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻏﻴﺮﻗﻄﻌﻲ ﺑﺎ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠﻪﺍﻱ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫ﺗﺸﺨﻴﺺ ﻣﺮﺗﺐ ﺑﻮﺩﻥ ﻳﮏ ﺁﺭﺍﻳﻪ‬
‫ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﻳﮏ ﺭﺷﺘﻪ ﻣﻔﺮﻭﺽ ﺷﺎﻣﻞ ﺯﻳﺮ ﺭﺷﺘﻪ ﺧﺎﺻﯽ ﻫﺴﺖ ﻳﺎ ﺧﻴﺮ‬
‫ﺗﺸﺨﻴﺺ ﻫﻤﺒﻨﺪ ﺑﻮﺩﻥ ﻳﮏ ﮔﺮﺍﻑ‬
‫ﻫﻤﮕﯽ ﺟﺰﻭ ﮐﻼﺱ ‪ P‬ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫ﺗﺸﺨﻴﺺ ﻣﺮﺗﺐ ﺑﻮﺩﻥ ﻳﮏ ﺁﺭﺍﻳﻪ‬
‫ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﻳﮏ ﺭﺷﺘﻪ ﻣﻔﺮﻭﺽ ﺷﺎﻣﻞ ﺯﻳﺮ ﺭﺷﺘﻪ ﺧﺎﺻﯽ ﻫﺴﺖ ﻳﺎ ﺧﻴﺮ‬
‫ﺗﺸﺨﻴﺺ ﻫﻤﺒﻨﺪ ﺑﻮﺩﻥ ﻳﮏ ﮔﺮﺍﻑ‬
‫ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﺁﻳﺎ ﺑﻴﺸﺘﺮﻳﻦ ﺳﻮﺩ ﺣﺎﺻﻞ ﺩﺭ ﻣﺴﺌﻠﻪ ﮐﻮﻟﻪ ﭘﺸﺘﯽ ﺻﻔﺮ ﻭ ﻳﮏ ﺍﺯ ﻣﻘﺪﺍﺭ ﺧﺎﺻﯽ ﺑﻴﺸﺘﺮ ﺍﺳﺖ‬
‫ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ﻣﻔﺮﻭﺽ ﺭﺍ ﻣﻴﺘﻮﺍﻥ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺑﻪ ﮔﻮﻧﻪ ﺍﯼ ﺍﻓﺮﺍﺯ ﮐﺮﺩ ﮐﻪ ﻣﺠﻤـﻮﻉ ﺩﻭ ﻗﺴـﻤﺖ ﻣﺴـﺎﻭﯼ‬
‫ﺑﺎﺷﺪ)ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺑﻪ ﻧﺎﻡ ‪ PARTITION‬ﺷﻨﺎﺧﺘﻪ ﻣﻴﺸﻮﺩ(‪.‬‬
‫ﺗﺸﺨﻴﺺ ﺍﻳﻨﮑﻪ ﻣﻴﺘﻮﺍﻥ ﺩﺭ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ﻣﻔﺮﻭﺽ ﻳﮏ ﺯﻳﺮ ﻣﺠﻤﻮﻋﻪ ﭘﻴﺪﺍ ﮐﺮﺩ ﮐﻪ ﻣﺠﻤﻮﻉ ﻋﻨﺎﺻﺮ ﺁﻥ ﺑﺮﺍﺑﺮ ﺑـﺎ ﻋـﺪﺩ ﺩﺍﺩﻩ‬
‫ﺷﺪﻩ ‪ M‬ﺑﺎﺷﺪ)ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﺑﻪ ﻧﺎﻡ ‪ Sum of Subset‬ﺷﻨﺎﺧﺘﻪ ﻣﻴﺸﻮﺩ(‪.‬‬
‫ﻫﻤﮕﯽ ﺟﺰﻭ ﮐﻼﺱ ‪ NP‬ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻧﮑﺘﻪ‪ :‬ﻫﺮ ﻣﺴﺌﻠﻪ ‪ P‬ﻣﺘﻌﻠﻖ ﺑﻪ ‪ NP‬ﻧﻴﺰ ﻣﻴﺒﺎﺷﺪ ﺑﻪ ﺑﻴﺎﻥ ﺩﻳﮕﺮ ﻫﻤﻴﺸﻪ ‪ .P⊆NP‬ﭼﻮﻥ ﺍﮔﺮ ﺑﺮﺍﯼ ﻣﺴﺌﻠﻪ ﺍﯼ ﺍﻟﮕﻮﺭﻳﺘﻢ ﻗﻄﻌـﯽ‬
‫ﭼﻨﺪ ﺟﻤﻠﻪ ﺍﯼ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻴﺘﻮﺍﻥ ﻫﻤﺎﻥ ﺍﻟﮕﻮﺭﻳﺘﻢ ﺭﺍ ﻋﻴﺮ ﻗﻄﻌﯽ ﻫﻢ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺖ‪.‬‬
‫‪٨٥‬‬
‫‬ ‫‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬

‫ت‬

‫ﻫﺮ ﻣﺴﺌﻠﻪ ﻗﻄﻌﻲ‪ ،‬ﻏﻴﺮﻗﻄﻌﻲ ﺁﻥ ﻧﻴﺰ ﻭﺟﻮﺩ ﺩﺍﺭﺩ‪.‬‬

‫ﻣﺴﺎﺋﻞ ﺑﻐﺮﻧﺞ )‪ :(intractable‬ﻣﺴﺎﺋﻠﻲ ﻛﻪ ﺛﺎﺑﺖ ﺷﺪﻩ ﺍﺳﺖ ﮐﻪ ﻣﺘﻌﻠﻖ ﺑﻪ ‪ NP‬ﻧﻴﺴﺘﻨﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﻣﺴﺌﻠﻪ ﺗﺸﺨﻴﺺ ﺍﻭﻝ ﺑﻮﺩﻥ ﻳﮏ ﻋﺪﺩ ‪ n‬ﺑﻴﺘﯽ ﺑﻐﺮﻧﺞ ﺍﺳﺖ‪.‬‬
‫ﮐﺎﻫﺶ )‪ (Reduce‬ﻳﺎ ﺗﺒﺪﻳﻞ‪ :‬ﮔﻮﻳﻴﻢ ﻣﺴﺌﻠﻪ ‪ A‬ﺩﺭ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠـﻪ ﺍﯼ ﺑـﻪ ‪ B‬ﺗﺒـﺪﻳﻞ ﻣﻴﺸـﻮﺩ )‪ (A∝p B‬ﺍﮔـﺮ ﻳـﮏ‬
‫ﺍﻟﮕﻮﺭﻳﺘﻢ ﺑﺮﺍﯼ ‪ B‬ﺭﺍ ﺑﺘﻮﺍﻥ ﺩﺭ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠﻪ ﺍﯼ ﺑﻪ ﺍﻟﮕﻮﺭﻳﺘﻤﯽ ﺑﺮﺍﯼ ‪ A‬ﺗﺒﺪﻳﻞ ﮐﺮﺩ ﻭ ﻳﺎ ﺑﻪ ﺑﻴـﺎﻥ ﺩﻳﮕـﺮ ﻳـﮏ ﺟـﻮﺍﺏ‬
‫ﺑﺮﺍﯼ ﻳﮏ ﻧﻤﻮﻧﻪ ﻣﺴﺌﻠﻪ ﺍﺯ ‪ B‬ﺩﺭ ﺯﻣﺎﻥ ﭼﻨﺪ ﺟﻤﻠﻪ ﺍﯼ ﻣﻨﺠﺮ ﺑﻪ ﻳﮏ ﺟﻮﺍﺏ ﺑﺮﺍﯼ ﻳﮏ ﻧﻤﻮﻧﻪ ﻣﺴﺌﻠﻪ ﺍﺯ ‪ A‬ﺷﻮﺩ‪.‬‬

‫ﻣﺜﺎﻝ‪:‬‬
‫‪Sorting ∝p Convex Hull‬‬
‫‪PARTITION ∝p Sum of Subset‬‬

‫ﻣﺮﺗﺐ ﮐﺮﺩﻥ ‪ n‬ﻋﺪﺩ ﺗﻮﺳﻂ ﺍﻟﮕﻮﺭﻳﺘﻢ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ‪ :‬ﺍﻋﺪﺍﺩ ﻭﺭﻭﺩﯼ ﺭﺍ ﻣﺨﺘﺼﻪ ‪ x‬ﺑﺮﺍﯼ ‪ n‬ﻧﻘﻄﻪ ﺩﺭ ﻧﻈﺮ ﻣﻴﮕﻴﺮﻳﻢ ﻭ ﺑـﻪ‬
‫ﻋﻨﻮﺍﻥ ﻣﺨﺘﺼﻪ ‪ y‬ﻣﻘﺪﺍﺭ ‪ x2‬ﺭﺍ ﺩﺭ ﻧﻈﺮ ﻣﻴﮕﻴﺮﻳﻢ‪ .‬ﺣﺎﻝ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ‪ n‬ﻧﻘﻄﻪ ﺭﺍ ﻣﻴﺴﺎﺯﻳﻢ‪ .‬ﻗﺎﺑﻞ ﺍﺛﺒﺎﺕ ﺍﺳﺖ ﮐﻪ ﺗﺮﺗﻴﺐ ‪x‬‬
‫ﻧﻘﺎﻁ ﺭﻭﯼ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﻣﺮﺗﺐ ﺷﺪﻩ ﺍﻋﺪﺍﺩ ﺍﻭﻟﻴﻪ ﻫﺴﺘﻨﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪:‬‬

‫‪٥‬‬ ‫‪٣‬‬ ‫‪٢‬‬ ‫‪١‬‬ ‫‪٤‬‬

‫‪٢٥‬‬ ‫‪٩‬‬ ‫‪٤‬‬ ‫‪١‬‬ ‫‪١٦‬‬

‫ﻧﮑﺘﻪ ‪ :‬ﺍﺯ ﻗﺎﺑﻞ ﺗﺒﺪﻳﻞ ﺑﻮﺩﻥ ﻣﺴﺌﻠﻪ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﺑﻪ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﻣﻴﺘﻮﺍﻥ ﺍﺛﺒﺎﺕ ﮐﺮﺩ ﮐﻪ ﺑﻬﺘـﺮﻳﻦ ﺍﻟﮕـﻮﺭﻳﺘﻢ ﺑـﺮﺍﯼ ﺗﻮﻟﻴـﺪ‬
‫ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﺩﺍﺭﺍﯼ ﺯﻣﺎﻥ )‪ O(n. log n‬ﻣﻴﺒﺎﺷﺪ!‪ .‬ﭼﻮﻥ ﺍﮔﺮ ﺑﺘﻮﺍﻥ ﭘﻮﺳﺘﻪ ﻣﺤﺪﺏ ﺭﺍ ﺩﺭ ﺯﻣﺎﻥ ﮐﻤﺘﺮ ﺍﺯ )‪O(n. log n‬‬
‫ﺗﻮﻟﻴﺪ ﮐﺮﺩ ﭘﺲ ﻣﺮﺗﺐ ﺳﺎﺯﯼ ﻫﻢ ﺩﺭ ﮐﻤﺘﺮ ﺍﺯ )‪ O(n. log n‬ﺍﻣﮑﺎﻥ ﭘﺬﻳﺮ ﺍﺳﺖ ﮐﻪ ﺍﻳﻦ ﻏﻴﺮ ﻣﻤﮑﻦ ﺍﺳـﺖ ﭼـﻮﻥ ﻣﺮﺗـﺐ‬
‫ﺳﺎﺯﯼ ‪ n‬ﻋﺪﺩ ﺗﻮﺳﻂ ﺍﻟﮕﻮﺭﻳﺘﻤﻬﺎﯼ ﻣﻘﺎﻳﺴﻪ ﺍﯼ ﺩﺭ ﺑﺪﺗﺮﻳﻦ ﺣﺎﻟﺖ )‪ Ω(n. log n‬ﺍﺳﺖ‪.‬‬

‫ﻣﺴﺌﻠﻪ ‪:NP-Complete‬‬
‫‪ A ∈ NP‬‬
‫‪A ∈ NPC ‬‬
‫‪∃B ∈ NPC | B α A‬‬
‫ﻣﺜﺎﻝ‪:‬‬
‫ﻣﺴﺌﻠﻪ ﻛﻮﻟﻪ ﭘﺸﺘﻲ ‪٠/١‬‬
‫ﻣﺴﺌﻠﻪ ﻓﺮﻭﺷﻨﺪﻩ ﺩﻭﺭﻩﮔﺮﺩ‬
‫ﻣﺴﺌﻠﻪ ‪PARTITION‬‬
‫ﻣﺴﺌﻠﻪ ﻭﺟﻮﺩ ﻭﻳﺎ ﻋﺪﻡ ﻭﺟﻮﺩ ﺩﻭﺭ ﻫﺎﻣﻴﻠﺘﻮﻧﯽ ﺩﺭ ﮔﺮﺍﻑ‬
‫ﻣﺴﺌﻠﻪ ‪Sum of Subset‬‬
‫ﻣﺴﺌﻠﻪ ﺭﻧﮓ ﺁﻣﻴﺰﯼ ﮔﺮﺍﻑ‬
‫ﻣﺴﺌﻠﻪ ﺗﺎ ﮐﺮﺩﻥ ﺧﻂ ﮐﺶ )‪(Ruler Folding‬‬
‫‪٨٦‬‬
‫‬ ‫‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬

‫ت‬

‫ﻣﺴﺌﻠﻪ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﻣﺴﻴﺮﯼ ﺑﻪ ﻃﻮﻝ ‪ k‬ﺩﺭ ﻳﮏ ﮔﺮﺍﻑ ﻭﺯﻥ ﺩﺍﺭ‬

‫ﻫﻤﮕﯽ ‪ NP-Complete‬ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻂ‬ ‫ﻪ‬
‫‪١‬‬
‫‪٨‬‬

‫ﻥ‬

‫ﺶ‬ ‫ﮐ‬ ‫ﺩ‬ ‫ﺮ‬ ‫ﮐ‬ ‫ﺎ‬ ‫ﺗ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﺧ‬ ‫ﻠ‬ ‫ﺌ‬

‫ﻳﻚ ﭘﺎﺭﻩﺧﻂ ﺑﺎ ﺗﻌﺪﺍﺩﻱ ﻣﻔﺼﻞ ﺑﺮ ﺭﻭﻱ ﺁﻥ ﺩﺍﺭﻳﻢ ﻛﻪ ﻫﺮ ﭘﺎﺭﻩ ﺧﻂ ﻣﻴﺘﻮﺍﻧﺪ ﺣﻮﻝ ﻣﻔﺎﺻﻞ ﺩﻭ ﻃـﺮﻓﺶ ﭼـﺮﺧﺶ ﺗـﺎ ‪٣٦٠‬‬
‫ﺩﺭﺟﻪ ﺭﺍ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬ﻫﺪﻑ ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻃﻮﻝ ﺣﺎﺻﻞ ﺍﺯ ﺗﺎ ﮐﺮﺩﻥ ﺍﻳﻦ ﭘﺎﺭﻩ ﺧﻄﻬﺎ ﺑﺮ ﺭﻭﯼ ﺧﻂ ﺍﻓﻘﯽ ﺍﺳﺖ‪.‬‬
‫‪٧‬‬ ‫‪٣‬‬ ‫‪١‬‬ ‫‪٩‬‬ ‫ﻣﺜﺎﻝ‪:‬‬
‫‪٢٠‬‬

‫‪٧‬‬

‫‪٣‬‬ ‫‪١T‬‬
‫‪١‬‬ ‫‪٩‬‬

‫‪٧‬‬ ‫‪٣‬‬
‫‪١٠‬‬
‫
‬ ‫‬ ‫‬

‫
‬

‫
‬

‫‬ ‫‬

‫‪٩‬‬ ‫‪١‬‬

‫)‪(PARTITION‬‬
‫ﺍ‬ ‫ﺍ‬ ‫ﻪ‬
‫‪٢‬‬
‫‪٨‬‬

‫ﺯ‬ ‫ﺮ‬ ‫ﻓ‬ ‫ﺴ‬ ‫ﻣ‬

‫‪-‬‬ ‫‪-‬‬

‫ﻠ‬ ‫ﺌ‬

‫ﺩﺭ ﺍﻳﻦ ﻣﺴﺌﻠﻪ ﻣﺠﻤﻮﻋﻪﺍﻱ ﺍﺯ ﺍﻋﺪﺍﺩ ﺩﺍﺩﻩ ﺷﺪﻩ ﺍﺳﺖ ﻭ ﻫﺪﻑ ﺍﻓﺮﺍﺯ ﻣﺠﻤﻮﻋﻪ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺑﻪ ﮔﻮﻧﻪ ﺍﯼ ﺍﺳﺖ ﮐﻪ ﻣﺠﻤـﻮﻉ‬
‫ﻋﻨﺎﺻﺮ ﺩﻭ ﻣﺠﻤﻮﻋﻪ ﻣﺴﺎﻭﯼ ﺑﺎﺷﺪ‪.‬‬
‫ﻣﺜﺎﻝ‪ :‬ﺑﺎ ﻭﺭﻭﺩﻱ ﻣﺠﻤﻮﻋﻪ ﺯﻳﺮ ﻣﺴﺌﻠﻪ ﭘﺎﺭﺗﻴﺸﻦ ﺑﻪ ﻧﺤﻮﻩﺍﻱ ﻛﻪ ﺩﺍﺭﺍﻱ ﻃﻮﻝﻫﺎﻱ ﻳﻜﺴﺎﻧﻲ ﺑﺎﺷﻨﺪ‪).‬ﻫﺰﻳﻨﻪﻫﺎﻱ ﻳﻜﺴﺎﻥ(‬

‫}‪{1,3, 7,9‬‬

‫}‪{3, 7‬‬ ‫}‪{1,9‬‬

‫‪٨٧‬‬
‫‬ ‫‬ ‫
‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬ ‫‬

‫ت‬

‫ﻣﺜﺎﻝ‪ :‬ﺛﺎﺑﺖ ﮐﻨﻴﺪ ﻣﺴﺌﻠﻪ ﺍﻓﺮﺍﺯ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ﻗﺎﺑﻞ ﺗﺒﺪﻳﻞ ﺑﻪ ﻣﺴﺌﻠﻪ ﭘﻴﺪﺍ ﮐﺮﺩﻥ ﻣﺴﻴﺮﯼ ﺑﻪ ﻃﻮﻝ ‪ k‬ﺩﺭ ﮔـﺮﺍﻑ ﺍﺳـﺖ‪ .‬ﺑـﺮﺍﯼ‬
‫ﺍﻳﻦ ﮐﺎﺭ ﮔﺮﺍﻓﯽ ﻣﻴﺴﺎﺯﻳﻢ ﮐﻪ ﺩﺍﺭﺍﯼ ‪ n+1‬ﺭﺍﺱ ﺍﺳﺖ‪ .‬ﺑﻴﻦ ﺭﺍﺱ ‪ i-1‬ﺍﻡ ﻭ ‪ i‬ﺍﻡ ﺩﻭ ﻳﺎﻝ ﺟﻬﺘﺪﺍﺭ ﺑﺮﻗـﺮﺍﺭ ﻣﻴﮑﻨـﻴﻢ‪ .‬ﻳـﺎﻝ ﺍﻭﻝ‬
‫ﺩﺍﺭﺍﯼ ﻫﺰﻳﻨﻪ ﻋﻨﺼﺮ ‪ i‬ﺍﻡ ﺍﺯ ﻣﺠﻤﻮﻋﻪ ﺍﻋﺪﺍﺩ ﺩﺍﺩﻩ ﺷﺪﻩ ﻭ ﻳﺎﻝ ﺩﻭﻡ ﺩﺍﺭﺍﯼ ﻣﻘﺪﺍﺭ ﻗﺮﻳﻨﻪ ﻳﺎﻝ ﺍﻭﻝ ﻣﻴﺒﺎﺷـﺪ‪ .‬ﺣـﺎﻝ ﭘﻴـﺪﺍ ﮐـﺮﺩﻥ‬
‫ﻣﺴﻴﺮﯼ ﺑﻪ ﻃﻮﻝ ﺻﻔﺮ ﺩﺭ ﺍﻳﻦ ﮔﺮﺍﻑ ﻣﻨﺠﺮ ﺑﻪ ﺍﻓﺮﺍﺯ ﻣﺠﻤﻮﻋﻪ ﺍﻭﻟﻴﻪ ﺑﻪ ﺩﻭ ﻗﺴﻤﺖ ﺑﺎ ﻣﺠﻤﻮﻉ ﻳﮑﺴﺎﻥ ﺧﻮﺍﻫﺪ ﺷﺪ!‪ .‬ﺍﻧﺘﺨﺎﺏ‬
‫ﻋﻨﺎﺻﺮ ﻣﺘﻨﺎﻇﺮ ﺑﺎ ﻳﺎﻟﻬﺎﯼ ﺍﻭﻝ ﺍﺯ ﻫﺮ ﺭﺍﺱ ﺑﻪ ﺭﺍﺱ ﺑﻌﺪﯼ ﺩﺭ ﻣﺴﻴﺮ ﻣﻮﺭﺩ ﻧﻈﺮ ﻣﻨﺠﺮ ﺑﻪ ﺍﻓﺮﺍﺯ ﻣﻮﺭﺩ ﻧﻈﺮ ﺧﻮﺍﻫﺪ ﺷﺪ‪.‬‬
‫ﻓﺮﺽ ﮐﻨﻴﺪ ﻫﺪﻑ ﺍﻓﺮﺍﺯ ﻣﺠﻤﻮﻋﻪ }‪ {3,1,7,9‬ﻣﻴﺒﺎﺷﺪ‪ .‬ﮔﺮﺍﻓﯽ ﺑﺼﻮﺭﺕ ﺯﻳﺮ ﺳـﺎﺧﺘﻪ ﻭ ﺩﺭ ﺁﻥ ﻣﺴـﻴﺮﻱ ﺍﺯ ‪ A‬ﺑـﻪ ‪ B‬ﺑـﻪ‬
‫ﻃﻮﻝ ﺻﻔﺮ ﺭﺍ ﺑﺮﺭﺳﯽ ﻣﻴﮑﻨﻴﻢ‪:‬‬

‫‪٣‬‬ ‫‪+١‬‬ ‫‪٧‬‬ ‫‪٩‬‬

‫‪A‬‬ ‫‪B‬‬

‫‪-٣‬‬ ‫‪-١‬‬ ‫‪-٧‬‬ ‫‪-٩‬‬

‫ﺩﻭ ﻣﺴﻴﺮ ﺑﺎ ﻫﺰﻳﻨﻪ ﺻﻔﺮ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﮐﻪ ﻳﮑﯽ ﺍﺯ ﺁﻧﻬﺎ ﺩﺭ ﺯﻳﺮ ﻧﺸﺎﻥ ﺩﺍﺩﻩ ﺷﺪﻩ ﺍﺳﺖ‪:‬‬

‫‪٣‬‬ ‫‪٧‬‬

‫‪A‬‬ ‫‪B‬‬

‫‪-١‬‬ ‫‪-٩‬‬

‫ﻣﻴﺘﻮﺍﻥ ﻧﺘﻴﺠﻪ ﮔﺮﻓﺖ ﻣﺠﻤﻮﻋﻪ ﻗﺎﺑﻞ ﺍﻓﺮﺍﺯ ﺑﻪ }‪ {3,7‬ﻭ }‪ {1,9‬ﻣﻴﺒﺎﺷﺪ‪.‬‬

‫ﻥ‬

‫ﺎ‬ ‫ﻳ‬ ‫ﺎ‬ ‫ﭘ‬

‫ﻧﮑﺘﻪ‪ :‬ﺧﻮﺍﻫﺸﻤﻨﺪﻡ ﺍﺷﮑﺎﻻﺕ ﻣﻮﺟﻮﺩ ﺩﺭ ﻣﻄﺎﻟﺐ ﺭﺍ ﺑﻪ ﺁﺩﺭﺱ ‪ nourollah@cic.aut.ac.ir‬ﺍﺭﺳﺎﻝ ﻓﺮﻣﺎﻳﻴﺪ‪.‬‬

‫ﻖ‬

‫ﻣ‬

‫ﻴ‬ ‫ﻓ‬ ‫ﻮ‬ ‫ﺗ‬ ‫ﷲ‬ ‫ﺍ‬ ‫ﻦ‬ ‫ﻭ‬

 ‫ﻣ‬ ‫ﻣ‬

‫ﻊ‬ ‫ﺟ‬ ‫ﺍ‬ ‫ﺮ‬ ‫ﻭ‬ ‫ﻊ‬ ‫ﺑ‬ ‫ﺎ‬ ‫ﻨ‬

[1] G. Brassard and P. Bratley, "Fundamentals of Algorithmic", Prentice-

Hall, 1996.
[2] Mark de Berg, Marc van Kreveld, Mark Overmars, and Otfried
Schwarzkopf, "Computational Geometry: Algorithms and
Applications", SpringerVerlag, 1997.
[3] T. H. Corman, C. E. Leiserson, R. L. Rivest, and C. Stein,
"Introduction to Algorithms", MIT Press and McGraw-Hill, 2001.
[4] E. Horowitz, S. Sahni, S. Rajasekaran, "Fundamentals of Computer
Algorithms", Computer Science Press, 1996.
[5] O'Rourke, Joseph, "Computational Geometry in C", Cambridge
University Press, Cambridge, UK, 1993.
[6] Preparata, F. P. and M. I. Shamos, "Computational Geometry: An
Introduction", Spinger-Verlag, New York, 1985.