จะอธิบายอัลกอริทึมพิสูจน์และวิเคราะห์ได้อย่างไร

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

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

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

ฉันไม่เคยเจอเรื่องแบบนี้เลย ข้อดีอีกอย่างคือเราสามารถนับจำนวนครั้งที่ดำเนินการแต่ละขั้นตอน ง่ายต่อการตรวจสอบกับกฎข้อแรกของ Kirchhoff ฉันไม่ได้วิเคราะห์เวลาทำงานอย่างแน่นอนดังนั้นบางส่วนอาจถูกตัดออกเมื่อฉันประเมินเวลาทำงาน$\pm1$

การวิเคราะห์คำสั่งของการเติบโตบางครั้งก็ไร้ประโยชน์ ตัวอย่างเช่นเราไม่สามารถแยกแยะ quicksort จาก heapsort ได้เนื่องจากทั้งหมดคือโดยที่คือจำนวนสุ่มตัวแปรคาดหวังดังนั้นเราควรวิเคราะห์ค่าคงที่พูดและE (T_2 (n)) = A_2 \ lg n + B_2n + O (\ log n)ดังนั้นเราสามารถเปรียบเทียบT_1และT_2ดีกว่า และบางครั้งเราควรเปรียบเทียบปริมาณอื่น ๆ เช่นความแปรปรวน การวิเคราะห์คำสั่งซื้อของการเจริญเติบโตของเวลาทำงานเท่านั้นไม่เพียงพอ ในฐานะที่เป็นTAOCPE X X E ( T 1 ( n ) ) = A 1 n lg n + B 1 n + O ( log n ) E ( T 2 ( n ) ) = 2 LG n + B 2 n + O $E(T(n))=\Theta(n\log n)$$EX$$X$$E(T_1(n))=A_1n\lg n+B_1n+O(\log n)$T 1 T $E(T_2(n))=A_2\lg n+B_2n+O(\log n)$$T_1$$T_2$ แปลอัลกอริธึมเป็นภาษาแอสเซมบลีและคำนวณเวลาทำงานมันยากเกินไปสำหรับฉันดังนั้นฉันต้องการทราบเทคนิคบางอย่างในการวิเคราะห์เวลาทำงานอีกเล็กน้อยซึ่งมีประโยชน์สำหรับภาษาระดับสูงเช่น C, C ++ หรือรหัสเทียม

และฉันต้องการที่จะรู้ว่าลักษณะของคำอธิบายส่วนใหญ่ที่ใช้ในงานวิจัยและวิธีการจัดการกับปัญหาเหล่านี้

มีวิธีการที่เป็นไปได้มากมายหลากหลาย สิ่งที่เหมาะสมที่สุดขึ้นอยู่กับ

• สิ่งที่คุณพยายามแสดง
• คุณต้องการหรือต้องการรายละเอียดมากน้อยเพียงใด

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

ฉันจะให้คุณสามตัวอย่างสำหรับอัลกอริทึมที่รู้จักกันดีการผสานซึ่งหวังว่าจะแสดงสิ่งนี้

ระดับสูง

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

เห็นได้ชัดว่าอัลกอริทึมนี้เป็นอัลกอริทึมการเรียงลำดับที่ถูกต้อง การแยกรายการและการรวมมันสามารถทำได้ในเวลาซึ่งทำให้เราเกิดซ้ำสำหรับกรณีที่เลวร้ายที่สุดT ( n ) = 2 T ( $\Theta(n)$) โดยทฤษฎีบทโทประเมินนี้เพื่อT(n)∈Θ(nlogn)$T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n)$$T(n) \in \Theta(n\log n)$

ระดับปานกลาง

การรวมอัลกอริทึมได้รับจากรหัสหลอกต่อไปนี้:

procedure mergesort(l : List) {
  if ( l.length < 2 ) {
    return l
  }

  left  = mergesort(l.take(l.length / 2)
  right = mergesort(l.drop(l.length / 2)
  result = []

  while ( left.length > 0 || right.length > 0 ) {
    if ( right.length == 0 || (left.length > 0 && left.head <= right.head) ) {
      result = left.head :: result
      left = left.tail
    }
    else {
      result = right.head :: result
      right = right.tail
    }
  }

  return result.reverse
}

เราพิสูจน์ความถูกต้องโดยอุปนัย สำหรับรายการที่มีความยาวเป็นศูนย์หรืออย่างใดอย่างหนึ่งอัลกอริทึมนั้นถูกต้องเล็กน้อย ในฐานะที่เป็นสมมติฐานเหนี่ยวนำสมมติmergesortดำเนินการอย่างถูกต้องในรายชื่อที่มีความยาวมากที่สุดสำหรับพลบางส่วน แต่คงธรรมชาติn > 1 ตอนนี้ขอLเป็นรายการยาวn + 1 โดยสมมติฐานการเหนี่ยวนำและการจัดเรียงรุ่นแรกของ resp แรก ครึ่งหลังของLหลังจากการเรียกซ้ำ ดังนั้นการเลือกวงในทุกองค์ประกอบที่เล็กย้ำไม่ตรวจสอบและยังผนวกมัน; จึงเป็นรายการที่ไม่เรียงลำดับมากขึ้นที่มีองค์ประกอบทั้งหมด$n$$n>1$$L$$n+1$leftright$L$whileresultresultleftrightและ ย้อนกลับเป็นรุ่นเรียงลำดับแบบไม่ลดลงซึ่งเป็นผลลัพธ์ที่ส่งคืนและที่ต้องการ$L$

สำหรับรันไทม์ให้เรานับการเปรียบเทียบองค์ประกอบและการดำเนินการรายการ (ซึ่งครองไทม์ asymptotically) รายการความยาวน้อยกว่าสองสาเหตุไม่ สำหรับรายการของความยาวเรามีการดำเนินงานที่เกิดจากการจัดเตรียมปัจจัยการผลิตสำหรับการโทรซ้ำผู้ที่มาจากสาย recursive ตัวเองบวกห่วงและเป็นหนึ่งใน พารามิเตอร์แบบเรียกซ้ำทั้งสองสามารถคำนวณได้ด้วยการดำเนินรายการไม่เกินnรายการแต่ละรายการ การวนซ้ำถูกดำเนินการอย่างแน่นอนnครั้งและการวนซ้ำทุกครั้งจะทำให้เกิดการเปรียบเทียบองค์ประกอบหนึ่งรายการและการดำเนินการรายการสองรายการ สุดท้ายสามารถนำมาใช้เพื่อใช้2 $n>1$whilereverse$n$while$n$reverse$2n$การดำเนินการรายการ - ทุกองค์ประกอบจะถูกลบออกจากอินพุตและใส่ลงในรายการเอาท์พุท ดังนั้นการดำเนินการนับตอบสนองการเกิดซ้ำดังต่อไปนี้:

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq T\left(\left\lceil\frac{n}{2}\right\rceil\right) + T\left(\left\lfloor\frac{n}{2}\right\rfloor\right) + 7n\end{align}$

เนื่องจากเห็นได้ชัดว่าไม่ลดลงจึงเพียงพอที่จะพิจารณาn = 2 kสำหรับการเจริญเติบโตของซีมโทติค ในกรณีนี้การเกิดซ้ำจะง่ายขึ้น$T$$n=2^k$

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq 2T\left(\frac{n}{2}\right) + 7n\end{align}$

โดยทฤษฎีบทปริญญาโทที่เราได้รับซึ่งทอดตัวรันไทม์ของ$T \in \Theta(n \log n)$mergesort

ระดับต่ำพิเศษ

พิจารณานี้ (ทั่วไป) การดำเนินงานของ mergesort ในอิสซาเบล / HOL :

types dataset  =  "nat * string"

fun leq :: "dataset \<Rightarrow> dataset \<Rightarrow> bool" where
   "leq (kx::nat, dx) (ky, dy) = (kx \<le> ky)"

fun merge :: "dataset list \<Rightarrow> dataset list \<Rightarrow> dataset list" where
"merge [] b = b" |
"merge a [] = a" |
"merge (a # as) (b # bs) = (if leq a b then a # merge as (b # bs) else b # merge (a # as) bs)"

function (sequential) msort :: "dataset list \<Rightarrow> dataset list" where
  "msort []  = []" |
  "msort [x] = [x]" |
  "msort l   = (let mid = length l div 2 in merge (msort (take mid l)) (msort (drop mid l)))"
by pat_completeness auto
  termination
  apply (relation "measure length")
by simp+

ซึ่งรวมถึงบทพิสูจน์ของความชัดเจนและการเลิกจ้าง ค้นหาหลักฐานถูกต้อง (เกือบ) สมบูรณ์ที่นี่

สำหรับ "รันไทม์" นั่นคือจำนวนการเปรียบเทียบการเกิดซ้ำที่คล้ายกับที่อยู่ในส่วนก่อนหน้านั้นสามารถตั้งค่าได้ แทนที่จะใช้ทฤษฎีบทต้นแบบและลืมค่าคงที่คุณสามารถวิเคราะห์เพื่อให้ได้ค่าประมาณที่เท่ากับเชิงปริมาณเท่ากับจำนวนจริง คุณสามารถค้นหาการวิเคราะห์แบบเต็มได้ใน [1]; นี่คือคร่าวๆ (มันไม่จำเป็นต้องพอดีกับรหัส Isabelle / HOL):

ดังกล่าวข้างต้นการเกิดซ้ำของจำนวนการเปรียบเทียบคือ

$\qquad \begin{align}f_0 = f_1 &= 0 \\ f_n &= f_{\left\lceil\frac{n}{2}\right\rceil} + f_{\left\lfloor\frac{n}{2}\right\rfloor} + e_n\end{align}$

โดยที่คือจำนวนการเปรียบเทียบที่จำเป็นสำหรับการผสานผลลัพธ์บางส่วน² เพื่อกำจัดพื้นและเพดานเราดำเนินการแยกความแตกต่างของเคสว่าnคือ:$e_n$$n$

$\qquad \displaystyle \begin{cases} f_{2m} &= 2f_m + e_{2m} \\ f_{2m+1} &= f_m + f_{m+1} + e_{2m+1} \end{cases}$

การใช้ความแตกต่างไปข้างหน้า / ถอยหลังแบบซ้อนของและe nเราได้สิ่งนั้น$f_n$$e_n$

1$\qquad \displaystyle \sum\limits_{k=1}^{n-1} (n-k) \cdot \Delta\kern-.2em\nabla f_k = f_n - nf_1$

ผลรวมตรงด้านขวามือของสูตร Perron ของ เรากำหนดชุดสร้าง Dirichletของเป็น$\Delta\kern-.2em\nabla f_k$

$\qquad \displaystyle W(s) = \sum\limits_{k\geq 1} \Delta\kern-.2em\nabla f_k k^{-s} = \frac{1}{1-2^{-s}} \cdot \underbrace{\sum\limits_{k \geq 1} \frac{\Delta\kern-.2em\nabla e_k}{k^s}}_{=:\ \boxminus(s)}$

ซึ่งพร้อมกับสูตรของ Perron ทำให้เรา

s$\qquad \displaystyle f_n = nf_1 + \frac{n}{2\pi i} \int\limits_{3-i\infty}^{3+i\infty} \frac{\boxminus(s)n^s}{(1-2^{-s})s(s+1)}ds$

การประเมินผลของขึ้นอยู่กับกรณีที่มีการวิเคราะห์ นอกเหนือจากนั้นเราสามารถ - หลังจากใช้เล่ห์เหลี่ยมบางอย่าง - ใช้ทฤษฎีที่เหลือเพื่อรับ$\boxminus(s)$

$\qquad \displaystyle f_n \sim n \cdot \log_2(n) + n \cdot A(\log_2(n)) + 1$

ที่เป็นฟังก์ชั่นระยะที่มีค่าใน[ - 1 , - 0.9 ]$A$$[-1,-0.9]$

1. Mellin แปลงและ asymptotics: การเกิดซ้ำของการควบรวมกิจการโดย Flajolet และ Golin (1992)
2. $e_n = \left\lfloor\frac{n}{2}\right\rfloor$
   $e_n = n-1$
   $e_n = n - \frac{\left\lfloor\frac{n}{2}\right\rfloor}{\left\lceil\frac{n}{2}\right\rceil + 1} - \frac{\left\lceil\frac{n}{2}\right\rceil}{\left\lfloor\frac{n}{2}\right\rfloor + 1}$

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

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

หลังจากนั้นเขาอธิบายว่าตัวเองเล็กแค่ไหนที่จะได้รับภาษามินิของเขา

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