การเขียนโปรแกรมแบบไดนามิกเกี่ยวกับอะไร?

ขออภัยล่วงหน้าหากคำถามนี้ฟังดูเป็นใบ้ ...

เท่าที่ฉันรู้การสร้างอัลกอริทึมโดยใช้การเขียนโปรแกรมแบบไดนามิกทำงานในลักษณะนี้:

1. แสดงปัญหาว่าเป็นความสัมพันธ์ที่เกิดซ้ำ;
2. ใช้ความสัมพันธ์ที่เกิดซ้ำทั้งผ่านการบันทึกและผ่านวิธีการจากล่างขึ้นบน

เท่าที่ฉันรู้ฉันได้กล่าวทุกอย่างเกี่ยวกับการเขียนโปรแกรมแบบไดนามิก ฉันหมายถึง: การเขียนโปรแกรมแบบไดนามิกไม่ได้ให้เครื่องมือ / กฎ / วิธีการ / ทฤษฎีบทสำหรับการแสดงความสัมพันธ์ที่เกิดขึ้นอีกหรือเปลี่ยนเป็นรหัส

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

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

วิธีการบันทึกและจากล่างขึ้นบนจะให้กฎ / วิธีสำหรับเปลี่ยนความสัมพันธ์ที่เกิดซ้ำเป็นรหัส การบันทึกเป็นความคิดที่ค่อนข้างง่าย แต่ความคิดที่ดีที่สุดมักจะเป็น!

การเขียนโปรแกรมแบบไดนามิกช่วยให้คุณคิดเกี่ยวกับเวลาทำงานของอัลกอริทึมของคุณ เวลาทำงานนั้นขึ้นอยู่กับตัวเลขสองตัวคือจำนวนของปัญหาย่อยที่คุณต้องแก้ไขและเวลาที่ใช้ในการแก้ปัญหาย่อยแต่ละรายการ นี่เป็นวิธีที่สะดวกในการคิดเกี่ยวกับปัญหาการออกแบบอัลกอริทึม เมื่อคุณมีความสัมพันธ์ที่เกิดซ้ำกับผู้สมัครคุณสามารถดูได้และรู้สึกได้อย่างรวดเร็วว่าเวลาทำงานอาจเป็นเท่าไหร่ (ตัวอย่างเช่นคุณมักจะสามารถบอกได้อย่างรวดเร็วว่ามีปัญหาย่อยจำนวนเท่าใดซึ่งเป็นขอบเขตล่างของ เวลาที่ใช้งานหากมีปัญหาย่อยมากมายที่คุณต้องแก้ปัญหาการเกิดซ้ำอาจจะไม่ใช่วิธีที่ดี) นอกจากนี้ยังช่วยให้คุณแยกแยะปัญหาย่อยสลายของผู้สมัคร ตัวอย่างเช่นถ้าเรามีสตริงกำหนด subproblem โดยคำนำหน้า S [ 1 .. ฉัน]หรือต่อท้าย S [ J . n ]หรือซับสตริง S [ i . . j ]อาจมีเหตุผล (จำนวนของปัญหาย่อยคือชื่อพหุนามใน n ) แต่การกำหนดปัญหาย่อยตามลำดับของ Sนั้นไม่น่าจะเป็นวิธีที่ดี (จำนวนของปัญหาย่อยเป็นเลขชี้กำลังใน n ) ซึ่งจะช่วยให้คุณตัด "ช่องว่างการค้นหา" ของการเกิดซ้ำที่เป็นไปได้$S[1..n]$$S[1..i]$$S[j..n]$$S[i..j]$$n$$S$$n$

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

• ถ้าอินพุตเป็นจำนวนเต็มบวก วิธีการหนึ่งในการกำหนด subproblem คือการแทนที่nด้วยจำนวนเต็มเล็กกว่าn ′ (st 0 ≤ n ′ ≤ n )$n$$n$$n'$$0 \le n' \le n$

• หากอินพุตเป็นสตริง วิธีการบางอย่างของผู้สมัครในการกำหนดปัญหาย่อย ได้แก่ : แทนที่S [ 1 .. n ]ด้วยคำนำหน้าS [ 1 .. i ] ; แทนที่S [ 1 .. n ]ด้วยคำต่อท้ายS [ j . . n ] ; แทนที่S [ 1 .. n ]ด้วยสตริงย่อยS [ i . . j $S[1..n]$$S[1..n]$$S[1..i]$$S[1..n]$$S[j..n]$$S[1..n]$$S[i..j]$. (ที่นี่ปัญหาย่อยถูกกำหนดโดยตัวเลือกของ .)$i,j$

• หากอินพุตเป็นรายการให้ทำเช่นเดียวกับที่คุณทำกับสตริง

• หากอินพุตเป็นtree หนึ่งทางเลือกในการกำหนด subproblem คือการแทนที่Tด้วยทรีย่อยของT (เช่นเลือกโหนดxและแทนที่Tด้วยทรีย่อยที่ root ที่xซึ่ง subproblem ถูกกำหนดโดยตัวเลือกของx )$T$$T$$T$$x$$T$$x$$x$

• หากอินพุตเป็นคู่ให้ดูชนิดของxและประเภทyซ้ำ ๆเพื่อระบุวิธีการเลือกปัญหาย่อยสำหรับแต่ละรายการ ในคำอื่น ๆ วิธีที่ผู้สมัครคนหนึ่งที่จะกำหนด subproblem คือการแทนที่( x , Y )โดย( x ' , Y ' )ที่x 'เป็น subproblem สำหรับxและy ที่'เป็น subproblem สำหรับปี (คุณสามารถพิจารณาปัญหาย่อยของแบบฟอร์ม( x , $(x,y)$$x$$y$$(x,y)$$(x',y')$$x'$$x$$y'$$y$หรือ ( x ′ , y ) .)$(x,y')$$(x',y)$

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

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

ความเข้าใจเกี่ยวกับการเขียนโปรแกรมแบบไดนามิกของคุณถูกต้อง ( afaik ) และคำถามของคุณเป็นธรรม

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

สมมติว่าอินพุตของเราคืออาร์เรย์เพื่อเน้นแนวคิด$A[1..n]$

1. วิธีการอุปนัย

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

   $\qquad f(A) = g\bigl( f(A[1..n-c]), A \bigr)$

   ด้วยฟังก์ชั่น / อัลกอริทึมที่แปลการแก้ปัญหา$g$

   ตัวอย่าง: การ หาซูเปอร์สตาร์ในเวลาเชิงเส้น

2. หาร & พิชิต

   แบ่งพาร์ติชันอินพุตเป็นชิ้นส่วนเล็ก ๆ หลาย ๆ อันแก้ปัญหาสำหรับแต่ละอันและรวมกัน แผนผัง (สำหรับสองส่วน)

   )$\qquad f(A) = g\bigl(f(A[1..c]), f(A[c+1..n]), A\bigr)$

   ตัวอย่าง:ผสาน - / Quicksort ระยะทางคู่สั้นที่สั้นที่สุดในระนาบ

3. การเขียนโปรแกรมแบบไดนามิก

   พิจารณาทุกวิธีในการแบ่งปัญหาออกเป็นปัญหาเล็ก ๆ และเลือกวิธีที่ดีที่สุด แผนผัง (สำหรับสองส่วน)

   }$\qquad f(A) = \operatorname{best} \Bigl\{ g\bigl(f(A[1..c]), f(A[c+1..n])\bigr) \Bigm| 1 \leq c \leq n-1 \Bigr\}$

   ตัวอย่าง:แก้ไขระยะทางปัญหาการเปลี่ยนแปลง

   หมายเหตุด้านที่สำคัญ: การเขียนโปรแกรมแบบไดนามิกไม่ได้ดุร้าย ! แอพพลิเคชั่นที่ในทุกขั้นตอนลดพื้นที่การค้นหาลงอย่างมาก$\operatorname{best}$

ในความรู้สึกคุณรู้น้อยลงเรื่อย ๆ จากบนลงล่างและต้องทำการตัดสินใจมากขึ้นเรื่อย ๆ แบบไดนามิก

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

Dynamic Programming allows you to trade memory for computation time. Consider the classic example, Fibonacci.

Fibonacci is defined by the recurrence $Fib(n)=Fib(n-1)+Fib(n-2)$. If you solve using this recursion, you end up doing $O(2^n)$ calls to $Fib(\cdot)$, since the recursion tree is a binary tree with height $n$.

Instead, you want to calculate $Fib(2)$, then use this to find $Fib(3)$, use that to find $Fib(4)$, etc. This only takes $O(n)$ time.

DP also provides us with basic techniques for translating a recurrence relation into a bottom-up solution, but these are relatively straightforward (and generally involve using an $m$ dimensional matrix, or a frontier of such a matrix, where $m$ is the number of parameters in the recurrence relation). These are well explained in any text about DP.

Here is another slightly different way of phrasing what dynamic programming gives you. Dynamic programming collapses an exponential number of candidate solutions into a polynomial number of equivalence classes, such that the candidate solutions in each class are indistinguishable in some sense.

Let me take as an example the problem of finding the number of increasing subsequences of length $k$ in an array $A$ of lenght $n$. It is useful to partition the set of all subsequences into equivalence classes such that two subsequences belong to the same class if and only if they have the same length and end in the same index. All of the $2^n$ possible subsequences belong to exactly one of the $O(n^2)$ equivalence classes. This partitioning preserves enough information so that we can define a recurrence relation for the sizes of the classes. If $f(i, \ell)$ gives the number of subsequences which end in index $i$ and have length $\ell$, then we have:

This recurrence solves the problem in time $O(n^2k)$.