การเขียนโปรแกรมแบบไดนามิก: ลักษณะตัวอย่างข้อดีข้อเสีย - เทคโนโลยี - 2026

การเขียนโปรแกรมแบบไดนามิกเป็นอัลกอริธึมแบบจำลองที่แก้ไขปัญหาที่ซับซ้อน โดย แบ่งออกเป็นปัญหาย่อยจัดเก็บผลลัพธ์เพื่อหลีกเลี่ยงการคำนวณผลลัพธ์ใหม่

กำหนดการนี้ใช้เมื่อคุณมีปัญหาที่สามารถแบ่งออกเป็นปัญหาย่อยที่คล้ายกันเพื่อให้สามารถนำผลลัพธ์กลับมาใช้ได้ โดยส่วนใหญ่แล้วกำหนดการนี้จะใช้สำหรับการเพิ่มประสิทธิภาพ

การเขียนโปรแกรมแบบไดนามิก ปัญหาย่อยที่ซ้อนทับในลำดับฟีโบนักชี ที่มา: Wikimedia commons, en: User: Dcoatzee, traced by User: Stannered / Public domain

ก่อนที่จะแก้ไขปัญหาย่อยที่มีอยู่อัลกอริทึมแบบไดนามิกจะพยายามตรวจสอบผลลัพธ์ของปัญหาย่อยที่แก้ไขก่อนหน้านี้ แนวทางแก้ไขปัญหาย่อยจะถูกรวมเข้าด้วยกันเพื่อให้ได้โซลูชันที่ดีที่สุด

แทนที่จะคำนวณปัญหาย่อยเดิมซ้ำแล้วซ้ำเล่าคุณสามารถจัดเก็บโซลูชันของคุณไว้ในหน่วยความจำบางส่วนเมื่อคุณพบปัญหาย่อยนี้เป็นครั้งแรก เมื่อปรากฏขึ้นอีกครั้งในระหว่างการแก้ปัญหาย่อยอื่นโซลูชันที่จัดเก็บไว้แล้วในหน่วยความจำจะถูกนำไป

นี่เป็นแนวคิดที่ยอดเยี่ยมสำหรับการแก้ไขเวลาในหน่วยความจำซึ่งการใช้พื้นที่เพิ่มเติมสามารถปรับปรุงเวลาที่ต้องใช้ในการค้นหาวิธีแก้ปัญหาได้

คุณสมบัติของการเขียนโปรแกรมแบบไดนามิก

คุณสมบัติที่สำคัญต่อไปนี้คือสิ่งที่คุณต้องมีปัญหาก่อนที่จะใช้โปรแกรมไดนามิกได้:

โครงสร้างย่อยที่เหมาะสมที่สุด

คุณลักษณะนี้เป็นการแสดงออกว่าปัญหาการเพิ่มประสิทธิภาพสามารถแก้ไขได้โดยการรวมโซลูชันที่เหมาะสมที่สุดของปัญหารองที่ประกอบด้วยปัญหานั้น โครงสร้างย่อยที่ดีที่สุดเหล่านี้อธิบายโดยการเรียกซ้ำ

ตัวอย่างเช่นในกราฟโครงสร้างย่อยที่เหมาะสมที่สุดจะถูกนำเสนอในเส้นทางที่สั้นที่สุด r ซึ่งไปจากจุดยอด s ถึงจุดยอด t:

นั่นคือในเส้นทางที่สั้นที่สุด r จุดยอดกลางใด ๆ ที่ฉันถ่ายได้ ถ้า r เป็นเส้นทางที่สั้นที่สุดจริงๆก็สามารถแบ่งออกเป็นรูทย่อย r1 (จาก s ถึง i) และ r2 (จาก i ถึง t) เพื่อให้เส้นทางเหล่านี้เป็นเส้นทางที่สั้นที่สุดระหว่างจุดยอดที่เกี่ยวข้อง

ดังนั้นเพื่อค้นหาเส้นทางที่สั้นที่สุดจึงสามารถกำหนดวิธีการแก้ปัญหาซ้ำได้อย่างง่ายดายซึ่งเป็นสิ่งที่อัลกอริธึม Floyd-Warshall ทำ

ปัญหาย่อยที่ทับซ้อนกัน

พื้นที่ปัญหาย่อยต้องมีขนาดเล็ก นั่นคืออัลกอริธึมแบบวนซ้ำใด ๆ ที่แก้ไขปัญหาจะต้องแก้ไขปัญหาย่อยเดิมซ้ำแล้วซ้ำเล่าแทนที่จะสร้างปัญหาย่อยใหม่

ตัวอย่างเช่นในการสร้างชุดฟีโบนักชีสามารถพิจารณาสูตรการเรียกซ้ำนี้ได้: Fn = F (n - 1) + F (n - 2) โดยพิจารณาจากกรณีฐานที่ F1 = F2 = 1 จากนั้นเราจะมี: F33 = F32 + F31 และ F32 = F31 + F30

อย่างที่คุณเห็น F31 กำลังได้รับการแก้ไขเป็นทรีย่อยแบบวนซ้ำของทั้ง F33 และ F32 แม้ว่าจำนวนปัญหาย่อยทั้งหมดจะน้อยมาก แต่หากคุณใช้วิธีแก้ปัญหาซ้ำซากเช่นนี้คุณจะต้องแก้ปัญหาเดิมซ้ำแล้วซ้ำเล่า

สิ่งนี้ถูกนำมาพิจารณาโดยการเขียนโปรแกรมแบบไดนามิกดังนั้นจึงแก้ปัญหาย่อยแต่ละปัญหาได้เพียงครั้งเดียว ซึ่งสามารถทำได้สองวิธี:

วิธีการจากบนลงล่าง

หากวิธีการแก้ปัญหาใด ๆ สามารถกำหนดรูปแบบซ้ำได้โดยใช้วิธีแก้ปัญหาย่อยและหากปัญหาย่อยเหล่านี้ทับซ้อนกันการแก้ไขปัญหาย่อยจะสามารถจดจำหรือจัดเก็บไว้ในตารางได้อย่างง่ายดาย

ทุกครั้งที่ค้นหาวิธีแก้ปัญหาย่อยใหม่ตารางจะถูกตรวจสอบเพื่อดูว่าก่อนหน้านี้ได้รับการแก้ไขแล้วหรือไม่ ในกรณีที่มีการจัดเก็บโซลูชันจะใช้แทนการคำนวณอีกครั้ง มิฉะนั้นปัญหาย่อยจะถูกแก้ไขโดยจัดเก็บโซลูชันไว้ในตาราง

แนวทางด้านล่างขึ้น

หลังจากที่วิธีการแก้ปัญหาถูกกำหนดซ้ำในแง่ของปัญหาย่อยแล้วคุณสามารถพยายามจัดรูปแบบปัญหาใหม่ในลักษณะจากน้อยไปหามากก่อนอื่นเราจะพยายามแก้ไขปัญหาย่อยและใช้แนวทางแก้ไขเพื่อหาแนวทางแก้ไขปัญหาย่อยที่ใหญ่กว่า

โดยทั่วไปแล้วจะทำในรูปแบบตารางโดยสร้างวิธีแก้ไขปัญหาย่อยที่ใหญ่ขึ้นและใหญ่ขึ้นซ้ำ ๆ โดยใช้วิธีแก้ไขปัญหาย่อยที่มีขนาดเล็กลง ตัวอย่างเช่นหากทราบค่าของ F31 และ F30 แล้วสามารถคำนวณค่า F32 ได้โดยตรง

เปรียบเทียบกับเทคนิคอื่น ๆ

คุณลักษณะที่สำคัญอย่างหนึ่งของปัญหาที่สามารถแก้ไขได้โดยการเขียนโปรแกรมแบบไดนามิกคือปัญหาย่อยที่ทับซ้อนกัน นี่คือสิ่งที่ทำให้การเขียนโปรแกรมแบบไดนามิกแตกต่างจากเทคนิคการหารและพิชิตโดยที่ไม่จำเป็นต้องเก็บค่าที่ง่ายที่สุด

คล้ายกับการเรียกซ้ำเนื่องจากเมื่อคำนวณกรณีพื้นฐานค่าสุดท้ายสามารถกำหนดได้โดยอุปนัย แนวทางจากล่างขึ้นบนนี้ใช้ได้ดีเมื่อค่าใหม่ขึ้นอยู่กับค่าที่คำนวณก่อนหน้านี้เท่านั้น

ตัวอย่าง

ขั้นต่ำในการเข้าถึง 1

สำหรับจำนวนเต็มบวก "e" ใด ๆ ในสามขั้นตอนต่อไปนี้สามารถทำได้

- ลบ 1 ออกจากจำนวน (e = e-1)

- ถ้าหารด้วย 2 หารด้วย 2 (ถ้า e% 2 == 0 แล้ว e = e / 2)

- ถ้าหารด้วย 3 หารด้วย 3 ได้ (ถ้า e% 3 == 0 แล้ว e = e / 3)

ตามขั้นตอนข้างต้นควรพบจำนวนขั้นต่ำของขั้นตอนเหล่านี้เพื่อนำ e ไปที่ 1 ตัวอย่างเช่น:

- ถ้า e = 1 ผลลัพธ์: 0

- ถ้า e = 4 ผลลัพธ์: 2 (4/2 = 2/2 = 1)

- เมื่อ e = 7 ผลลัพธ์: 3 (7-1 = 6/3 = 2/2 = 1)

โฟกัส

คนหนึ่งอาจคิดว่าจะเลือกขั้นตอนที่ทำให้ n ต่ำที่สุดเท่าที่จะเป็นไปได้และทำแบบนี้ไปเรื่อย ๆ จนกว่าจะถึง 1 อย่างไรก็ตามจะเห็นได้ว่ากลยุทธ์นี้ใช้ไม่ได้กับที่นี่

ตัวอย่างเช่นถ้า e = 10 ขั้นตอนจะเป็น: 10/2 = 5-1 = 4/2 = 2/2 = 1 (4 ขั้นตอน) อย่างไรก็ตามรูปแบบที่เหมาะสมที่สุดคือ: 10-1 = 9/3 = 3/3 = 1 (3 ขั้นตอน) ดังนั้นจึงต้องลองขั้นตอนที่เป็นไปได้ทั้งหมดที่สามารถทำได้สำหรับแต่ละค่าของ n ที่พบโดยเลือกจำนวนขั้นต่ำของความเป็นไปได้เหล่านี้

ทุกอย่างเริ่มต้นด้วยการเรียกซ้ำ: F (e) = 1 + นาที {F (e-1), F (e / 2), F (e / 3)} ถ้า e> 1 โดยใช้เป็นตัวพิมพ์ฐาน: F (1) = 0. มีสมการการเกิดซ้ำคุณสามารถเริ่มเขียนโค้ดการเรียกซ้ำได้

อย่างไรก็ตามจะเห็นได้ว่ามันมีปัญหาย่อยที่ทับซ้อนกัน นอกจากนี้โซลูชันที่ดีที่สุดสำหรับอินพุตที่กำหนดขึ้นอยู่กับการแก้ไขปัญหาย่อยที่เหมาะสมที่สุด

เช่นเดียวกับการท่องจำที่ซึ่งคำตอบของปัญหาย่อยที่ได้รับการแก้ไขจะถูกเก็บไว้เพื่อใช้ในภายหลัง หรือในการเขียนโปรแกรมแบบไดนามิกคุณเริ่มต้นที่ด้านล่างโดยเริ่มต้นจนถึง e ที่กำหนด จากนั้นรหัสทั้งสอง:

การท่องจำ

การเขียนโปรแกรมด้านล่างแบบไดนามิก

ความได้เปรียบ

ข้อดีหลักอย่างหนึ่งของการใช้โปรแกรมไดนามิกคือความเร็วในการประมวลผลเนื่องจากมีการใช้การอ้างอิงที่คำนวณก่อนหน้านี้ เนื่องจากเป็นเทคนิคการเขียนโปรแกรมแบบวนซ้ำจึงช่วยลดบรรทัดของโค้ดในโปรแกรม

อัลกอริทึมที่โลภและการเขียนโปรแกรมแบบไดนามิก

อัลกอริทึมโลภคล้ายกับการเขียนโปรแกรมแบบไดนามิกเนื่องจากเป็นเครื่องมือสำหรับการเพิ่มประสิทธิภาพ อย่างไรก็ตามอัลกอริทึมโลภจะมองหาโซลูชันที่เหมาะสมที่สุดในแต่ละขั้นตอนในพื้นที่ นั่นคือมันแสวงหาทางเลือกที่โลภด้วยความหวังว่าจะได้พบกับสิ่งที่ดีที่สุดในระดับโลก

ดังนั้นอัลกอริทึมโลภสามารถสร้างสมมติฐานที่ดูดีที่สุดในเวลานั้น แต่จะมีราคาแพงในอนาคตและไม่รับประกันว่าจะดีที่สุดในระดับโลก

ในทางกลับกันการเขียนโปรแกรมแบบไดนามิกจะพบวิธีแก้ปัญหาที่เหมาะสมที่สุดสำหรับปัญหาย่อยจากนั้นจึงทำการเลือกอย่างมีข้อมูลโดยการรวมผลลัพธ์ของปัญหาย่อยเหล่านั้นเพื่อค้นหาโซลูชันที่เหมาะสมที่สุด

ข้อเสีย

- จำเป็นต้องใช้หน่วยความจำมากในการจัดเก็บผลลัพธ์ที่คำนวณได้ของแต่ละปัญหาย่อยโดยไม่สามารถรับประกันได้ว่าจะใช้ค่าที่จัดเก็บไว้หรือไม่

- หลายครั้งค่าเอาต์พุตจะถูกจัดเก็บโดยไม่เคยถูกใช้ในปัญหาย่อยต่อไปนี้ระหว่างการดำเนินการ สิ่งนี้นำไปสู่การใช้หน่วยความจำโดยไม่จำเป็น

- ในการเขียนโปรแกรมแบบไดนามิกฟังก์ชันจะถูกเรียกซ้ำ สิ่งนี้ช่วยให้หน่วยความจำสแตกเพิ่มขึ้นอย่างต่อเนื่อง

การเขียนซ้ำเทียบกับการเขียนโปรแกรมแบบไดนามิก

หากคุณมีหน่วยความจำที่ จำกัด ในการรันโค้ดและความเร็วในการประมวลผลก็ไม่น่ากังวลคุณสามารถใช้การเรียกซ้ำได้ ตัวอย่างเช่นหากคุณกำลังพัฒนาแอปพลิเคชันบนมือถือหน่วยความจำมีข้อ จำกัด ในการเรียกใช้แอปพลิเคชัน

หากคุณต้องการให้โปรแกรมทำงานได้เร็วขึ้นและไม่มีข้อ จำกัด ของหน่วยความจำแนะนำให้ใช้การเขียนโปรแกรมแบบไดนามิก

การประยุกต์ใช้งาน

การเขียนโปรแกรมแบบไดนามิกเป็นวิธีการแก้ปัญหาที่มีประสิทธิภาพซึ่งอาจดูยากมากที่จะแก้ไขในระยะเวลาที่เหมาะสม

อัลกอริทึมตามกระบวนทัศน์การเขียนโปรแกรมแบบไดนามิกถูกนำไปใช้ในหลาย ๆ ด้านของวิทยาศาสตร์รวมถึงตัวอย่างมากมายในปัญญาประดิษฐ์ตั้งแต่การวางแผนการแก้ปัญหาไปจนถึงการรู้จำเสียง

อัลกอริทึมตามการเขียนโปรแกรมแบบไดนามิก

การเขียนโปรแกรมแบบไดนามิกค่อนข้างมีประสิทธิภาพและทำงานได้ดีสำหรับปัญหาต่างๆ อัลกอริทึมจำนวนมากสามารถมองเห็นได้ว่าเป็นแอปพลิเคชันอัลกอริทึมแบบโลภเช่น:

- ชุดหมายเลขฟีโบนักชี

- หอคอยแห่งฮานอย

- เส้นทางที่สั้นกว่าทุกคู่ผ่าน Floyd-Warshall

- ปัญหากระเป๋าเป้.

- การจัดกำหนดการโครงการ

- ทางที่สั้นที่สุดผ่าน Dijkstra

- การควบคุมการบินและการควบคุมหุ่นยนต์

- ปัญหาการเพิ่มประสิทธิภาพทางคณิตศาสตร์

- Timeshare: กำหนดเวลางานเพื่อเพิ่มการใช้งาน CPU ให้สูงสุด

อนุกรมเลขฟีโบนักชี

หมายเลขฟีโบนักชีเป็นตัวเลขที่พบในลำดับต่อไปนี้: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 เป็นต้น

ในคำศัพท์ทางคณิตศาสตร์ลำดับ Fn ของตัวเลข Fibonacci ถูกกำหนดโดยสูตรการเกิดซ้ำ: F (n) = F (n -1) + F (n -2) โดยที่ F (0) = 0 และ F ( 1) = 1.

วิธีการจากบนลงล่าง

ในตัวอย่างนี้อาร์เรย์การค้นหาที่มีค่าเริ่มต้นทั้งหมดจะเริ่มต้นด้วย -1 เมื่อใดก็ตามที่ต้องการวิธีแก้ปัญหาย่อยเมทริกซ์การค้นหานี้จะถูกค้นหาก่อน

หากมีค่าที่คำนวณได้ค่านั้นจะถูกส่งกลับ มิฉะนั้นผลลัพธ์จะถูกคำนวณเพื่อเก็บไว้ในอาร์เรย์การค้นหาเพื่อให้สามารถใช้ซ้ำได้ในภายหลัง

แนวทางด้านล่างขึ้น

ในกรณีนี้สำหรับอนุกรมฟีโบนักชีเดียวกัน f (0) จะถูกคำนวณก่อนจากนั้น f (1), f (2), f (3) และอื่น ๆ ดังนั้นการแก้ไขปัญหาย่อยจึงถูกสร้างขึ้นจากด้านล่างขึ้นบน

อ้างอิง

1. Vineet Choudhary (2020). ข้อมูลเบื้องต้นเกี่ยวกับการเขียนโปรแกรมแบบไดนามิก Insider ของนักพัฒนานำมาจาก: developerinsider.co.
2. อเล็กซ์อัลเลน (2020) การเขียนโปรแกรมแบบไดนามิกใน C ++ การเขียนโปรแกรม C นำมาจาก: cprogramming.com.
3. After Academy (2020). แนวคิดของการเขียนโปรแกรมแบบไดนามิก นำมาจาก: afteracademy.com.
4. อนิรุท ธ ชะฮารี (2019). การเขียนโปรแกรมแบบไดนามิกและการเรียกซ้ำ - ความแตกต่างข้อดีพร้อมตัวอย่าง กอง CSE นำมาจาก: csestack.org.
5. Code Chef (2020) บทช่วยสอนสำหรับการเขียนโปรแกรมแบบไดนามิก นำมาจาก: codechef.com.
6. Programiz (2020) การเขียนโปรแกรมแบบไดนามิก นำมาจาก: programiz.com.