มีระบบเบื้องหลังการวิเคราะห์อัลกอริทึมหรือไม่?

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

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

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

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

การแปลรหัสเป็นคณิตศาสตร์

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

ตัวอย่าง: การเปรียบเทียบใน Bubblesort

พิจารณาอัลกอริธึมที่จัดเรียงอาร์เรย์ที่กำหนดA:

 bubblesort(A) do                   1
  n = A.length;                     2
  for ( i = 0 to n-2 ) do           3
    for ( j = 0 to n-i-2 ) do       4
      if ( A[j] > A[j+1] ) then     5
        tmp    = A[j];              6
        A[j]   = A[j+1];            7
        A[j+1] = tmp;               8
      end                           9
    end                             10
  end                               11
end                                 12

สมมติว่าเราต้องการทำการวิเคราะห์อัลกอริทึมการเรียงลำดับตามปกติซึ่งนับจำนวนการเปรียบเทียบองค์ประกอบ (บรรทัดที่ 5) เราทราบได้ทันทีว่าปริมาณนี้ไม่ได้ขึ้นอยู่กับเนื้อหาของอาร์เรย์Aเพียงกับความยาวของnดังนั้นเราจึงสามารถแปล (ซ้อน) - ลูปค่อนข้างเป็นผลรวม (ซ้อน) รวมกัน; ตัวแปรลูปจะกลายเป็นตัวแปรการสรุปรวมและช่วงการดำเนินการ เราได้รับ:$n$for

$\qquad\displaystyle C_{\text{cmp}}(n) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \dots = \frac{n(n-1)}{2} = \binom{n}{2}$ ,

โดยที่คือค่าใช้จ่ายสำหรับการดำเนินการแต่ละบรรทัด 5 (ซึ่งเรานับ)$1$

ตัวอย่าง: Swaps ใน Bubblesort

ฉันจะแสดงโดยโปรแกรมย่อยที่ประกอบด้วยบรรทัดไปและโดยค่าใช้จ่ายสำหรับการดำเนินการโปรแกรมย่อยนี้ (หนึ่งครั้ง)$P_{i,j}$ij$C_{i,j}$

ตอนนี้ขอบอกว่าเราต้องการนับแลกเปลี่ยนที่เป็นวิธีการที่มักจะถูกดำเนินการ นี่คือ "บล็อกพื้นฐาน" ซึ่งเป็นโปรแกรมย่อยที่จะดำเนินการทางอะตอมเสมอและมีค่าใช้จ่ายคงที่ (ที่นี่ ) การทำสัญญาบล็อกดังกล่าวเป็นสิ่งที่มีประโยชน์อย่างหนึ่งที่เรามักใช้โดยไม่ต้องคิดหรือพูดถึงมัน$P_{6,8}$$1$

ด้วยการแปลที่คล้ายกันข้างต้นเรามาถึงสูตรต่อไปนี้:

$\qquad\displaystyle C_{\text{swaps}}(A) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$j)})

$A^{(i,j)}$หมายถึงรัฐอาเรย์ก่อนย้ำ -th ของ{5,9}$(i,j)$$P_{5,9}$

โปรดทราบว่าฉันใช้แทนเป็นพารามิเตอร์ เราจะเห็นว่าทำไมในไม่ช้า ฉันไม่ได้เพิ่มและเป็นพารามิเตอร์ของเนื่องจากค่าใช้จ่ายไม่ได้ขึ้นอยู่กับพวกเขาที่นี่ (ในรูปแบบค่าใช้จ่ายสม่ำเสมอนั่นคือ); โดยทั่วไปพวกเขาอาจจะ$A$$n$$i$$j$$C_{5,9}$

เห็นได้ชัดว่าค่าใช้จ่ายของขึ้นอยู่กับเนื้อหาของ (ค่าและโดยเฉพาะ) ดังนั้นเราจึงต้องคำนึงถึงสิ่งนั้น ตอนนี้เราเผชิญกับความท้าทาย: เราจะ "แกะ"อย่างไร เราสามารถพึ่งพาเนื้อหาของอย่างชัดเจน:$P_{5,9}$$A$A[j]A[j+1]$C_{5,9}$$A$

$\qquad\displaystyle C_{5,9}(A^{(i,j)}) = C_5(A^{(i,j)}) + \begin{cases} 1 &, \mathtt{A^{(i,j)}[j] > A^{(i,j)}[j+1]} \\ 0 &, \text{else} \end{cases}${}

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

1. กรณีที่เลวร้ายที่สุด

   เพียงแค่ดูที่ผลรวมและสังเกตว่า , เราสามารถหาขอบเขตบนเล็กน้อยสำหรับค่าใช้จ่าย:$C_{5,9}(A^{(i,j)}) \in \{0,1\}$

   $\qquad\displaystyle C_{\text{swaps}}(A) \leq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \frac{n(n-1)}{2} = \binom{n}{2}${2}

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

2. กรณีที่ดีที่สุด

   ตรงกันข้ามมีขอบเขตล่างที่น่ารำคาญ:

   $\qquad\displaystyle C_{\text{swaps}}(A) \geq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 0 = 0$0

   สิ่งนี้สามารถเกิดขึ้นได้: ในอาร์เรย์ที่เรียงลำดับแล้ว Bubblesort จะไม่ทำการสลับครั้งเดียว

3. กรณีเฉลี่ย

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

   จากนั้นเราสามารถเขียนค่าใช้จ่ายเช่นนี้²:

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

   ตอนนี้เราต้องไปไกลกว่าการจัดการกับผลรวมอย่างง่าย โดยการดูอัลกอริทึมเราทราบว่าการสลับทุกครั้งจะลบการผกผันเดียวใน (เราเพียงแค่สลับneighbours³) นั่นคือจำนวนของสัญญาแลกเปลี่ยนดำเนินการในเป็นว่าจำนวน inversionsของ ดังนั้นเราสามารถแทนที่ผลรวมสองภายในและรับ$A$$A$$\operatorname{inv}(A)$$A$

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \operatorname{inv}(A)$(A)

   โชคดีที่เรามีจำนวนผู้รุกรานโดยเฉลี่ยที่พิจารณาแล้วว่าเป็น

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{2} \cdot \binom{n}{2}$

   ซึ่งเป็นผลสุดท้ายของเรา โปรดทราบว่านี่เป็นครึ่งราคาที่เลวร้ายที่สุด

1. โปรดทราบว่าอัลกอริทึมได้รับการกำหนดอย่างรอบคอบเพื่อให้การวนซ้ำ "ครั้งสุดท้าย" i = n-1ของลูปด้านนอกที่ไม่เคยทำสิ่งใด ๆ
2. " " เป็นสัญลักษณ์ทางคณิตศาสตร์สำหรับ "ค่าที่คาดหวัง" ซึ่งนี่เป็นค่าเฉลี่ย$\mathbb{E}$
3. เราเรียนรู้ไปตามวิธีที่ไม่มีอัลกอริทึมที่แลกเปลี่ยนองค์ประกอบใกล้เคียงเท่านั้นที่สามารถ asymptotically เร็วกว่า Bubblesort (แม้โดยเฉลี่ย) - จำนวนการรุกรานนั้นมีขอบเขตต่ำกว่าสำหรับอัลกอริธึมดังกล่าวทั้งหมด นี้นำไปใช้เช่นการแทรกเรียงและการเลือกเรียง

วิธีการทั่วไป

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

เราแสดงสถานะปัจจุบันด้วย (ลองจินตนาการว่ามันเป็นชุดของการกำหนดตัวแปร) เมื่อเรารันโปรแกรมที่เริ่มต้นใน stateเราจะสิ้นสุดใน state ( ถูกยกเลิก)$\psi$P$\psi$$\psi / \mathtt{P}$P

• งบส่วนบุคคล

  รับเพียงคำเดียวS;, คุณกำหนดค่าใช้จ่ายปอนด์ต่อตารางนิ้ว) โดยทั่วไปจะเป็นฟังก์ชันคงที่$C_S(\psi)$

• การแสดงออก

  หากคุณมีการแสดงออกEของแบบฟอร์มE1 ∘ E2(พูดการแสดงออกทางคณิตศาสตร์ที่∘อาจจะเพิ่มหรือการคูณคุณจะเพิ่มค่าใช้จ่ายซ้ำ:

  $\qquad\displaystyle C_E(\psi) = c_{\circ} + C_{E_1}(\psi) + C_{E_2}(\psi)$ปอนด์ต่อตารางนิ้ว)

  สังเกตได้ว่า

  • ค่าใช้จ่ายในการดำเนินงานอาจไม่คงที่ แต่ขึ้นอยู่กับค่าของและและ$c_{\circ}$$E_1$$E_2$
  • การประเมินผลของนิพจน์อาจเปลี่ยนแปลงสถานะในหลายภาษา

  ดังนั้นคุณอาจต้องยืดหยุ่นกับกฎนี้

• ลำดับ

  เมื่อให้โปรแกรมPเป็นลำดับของโปรแกรมQ;Rคุณจะต้องเพิ่มค่าใช้จ่าย

  $\qquad\displaystyle C_P(\psi) = C_Q(\psi) + C_R(\psi / \mathtt{Q})${Q})

• เงื่อนไข

  ให้โปรแกรมPของแบบฟอร์มif A then Q else R endค่าใช้จ่ายขึ้นอยู่กับสถานะ:

  $\qquad\displaystyle C_P(\psi) = C_A(\psi) + \begin{cases} C_Q(\psi/\mathtt{A}) &, \mathtt{A} \text{ evaluates to true under } \psi \\ C_R(\psi/\mathtt{A}) &, \text{else} \end{cases}$

  โดยทั่วไปการประเมินAอาจเปลี่ยนแปลงสถานะได้ดีดังนั้นการอัพเดทค่าใช้จ่ายของแต่ละสาขา

• สำหรับลูป

  รับโปรแกรมPของแบบฟอร์มfor x = [x1, ..., xk] do Q endกำหนดค่าใช้จ่าย

  $\qquad\displaystyle C_P(\psi) = c_{\text{init_for}} + \sum_{i=1}^k c_{\text{step_for}} + C_Q(\psi_i \circ \{\mathtt{x := xi\}})$

  ที่เป็นรัฐก่อนการประมวลผลสำหรับค่าคือหลังจากที่ซ้ำกับที่ถูกตั้งค่าให้, ... ,$\psi_i$Qxixx1xi-1

  สังเกตค่าคงที่พิเศษสำหรับการบำรุงรักษาลูป ต้องสร้างตัวแปรลูป ( ) และกำหนดค่า ( ) สิ่งนี้มีความเกี่ยวข้องตั้งแต่$c_{\text{init_for}}$$c_{\text{step_for}}$

  • การคำนวณครั้งต่อไปxiอาจมีค่าใช้จ่ายสูงและ
  • - forลูปที่มีเนื้อความว่างเปล่า (เช่นหลังจากทำให้การตั้งค่าที่ดีที่สุดในกรณีที่ง่ายที่สุดด้วยค่าใช้จ่ายเฉพาะ) ไม่มีค่าใช้จ่ายใด ๆ หากมันทำการวนซ้ำ

• ในขณะที่ลูป

  รับโปรแกรมPของแบบฟอร์มwhile A do Q endกำหนดค่าใช้จ่าย

  $\qquad\displaystyle C_P(\psi) \\\qquad\ = C_A(\psi) + \begin{cases} 0 &, \mathtt{A} \text{ evaluates to false under } \psi \\ C_Q(\psi/\mathtt{A}) + C_P(\psi/\mathtt{A;Q}) &, \text{ else} \end{cases}$

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

  ตัวอย่าง:พิจารณาอัลกอริธึมสั้น ๆ นี้:

  while x > 0 do    1
    i += 1          2
    x = x/2         3
  end               4
  

  โดยการใช้กฎเราจะได้รับ

  $\qquad\displaystyle C_{1,4}(\{i := i_0; x := x_0\}) \\\qquad\ = c_< + \begin{cases} 0 &, x_0 \leq 0 \\ c_{+=} + c_/ + C_{1,4}(\{i := i_0 + 1; x := \lfloor x_0/2 \rfloor\}) &, \text{ else} \end{cases}$

  ด้วยค่าใช้จ่ายคงที่บางรายการสำหรับแต่ละข้อความสั่ง เราถือว่าโดยปริยายว่าสิ่งเหล่านี้ไม่ได้ขึ้นอยู่กับสถานะ (ค่าของและ); สิ่งนี้อาจจะใช่หรือไม่ใช่จริงใน "ความจริง": คิดว่าล้น!$c_{\dots}$ix

  ตอนนี้เราต้องแก้ปัญหาการเกิดซ้ำนี้{1,4} เราทราบว่าจำนวนการทำซ้ำไม่ใช่ค่าใช้จ่ายของลูปบอดี้นั้นขึ้นอยู่กับค่าของดังนั้นเราจึงสามารถวางได้ เราถูกทิ้งให้อยู่กับการเกิดซ้ำนี้:$C_{1,4}$i

  $\qquad\displaystyle C_{1,4}(x) = \begin{cases} c_> &, x \leq 0 \\ c_> + c_{+=} + c_/ + C_{1,4}(\lfloor x/2 \rfloor) &, \text{ else} \end{cases}$

  นี้แก้ด้วยวิธีการประถมศึกษาเพื่อ

  $\qquad\displaystyle C_{1,4}(\psi) = \lceil \log_2 \psi(x) \rceil \cdot (c_> + c_{+=} + c_/) + c_>$ ,

  แนะนำสถานะเต็มรูปแบบให้เป็นสัญลักษณ์ ถ้าแล้ว5$\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• ขั้นตอนการโทร

  รับโปรแกรมPของฟอร์มM(x)สำหรับพารามิเตอร์บางตัวโดยxที่Mโพรซีเดอร์ที่มีพารามิเตอร์ (ตั้งชื่อ) pกำหนดค่าใช้จ่าย

  $\qquad\displaystyle C_P(\psi) = c_{\text{call}} + C_M(\psi_{\text{glob}} \circ \{p := x\})$\})

  โปรดทราบอีกครั้งว่าค่าคงที่พิเศษ (ซึ่งอันที่จริงแล้วขึ้นอยู่กับ !) การเรียกใช้โปรซีเจอร์นั้นมีราคาแพงเนื่องจากวิธีการใช้งานบนเครื่องจริงและบางครั้งก็ควบคุมการรันไทม์ (เช่นการประเมินจำนวนฟีโบนัชชีซ้ำ ๆ อย่างไร้เดียงสา)$c_{\text{call}}$$\psi$

  ฉันแก้ไขปัญหาทางความหมายบางอย่างที่คุณอาจมีกับรัฐที่นี่ คุณจะต้องการแยกแยะสถานะโกลบอลและโลคอลการเรียกโพรซีเดอร์ ขอเพียงถือว่าเราผ่านรัฐเดียวทั่วโลกที่นี่และMได้รับรัฐท้องถิ่นใหม่เริ่มต้นได้โดยการตั้งค่าของการp xนอกจากนี้xอาจเป็นนิพจน์ที่เรา (ปกติ) คิดว่าจะได้รับการประเมินก่อนส่ง

  ตัวอย่าง:พิจารณาขั้นตอน

  fac(n) do                  
    if ( n <= 1 ) do         1
      return 1               2
    else                     3
      return n * fac(n-1)    4
    end                      5
  end                        
  

  ตามกฎเราได้รับ:

  $\qquad\displaystyle\begin{align*} C_{\text{fac}}(\{n := n_0\}) &= C_{1,5}(\{n := n_0\}) \\ &= c_{\leq} + \begin{cases} C_2(\{n := n_0 \}) &, n_0 \leq 1 \\ C_4(\{n := n_0 \}) &, \text{ else} \end{cases} \\ &= c_{\leq} + \begin{cases} c_{\text{return}} &, n_0 \leq 1 \\ c_{\text{return}} + c_* + c_{\text{call}} + C_{\text{fac}}(\{n := n_0 - 1\}) &, \text{ else} \end{cases} \end{align*}$

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

  $\qquad\displaystyle C_{\text{fac}}(\psi) = \psi(n) \cdot (c_{\leq} + c_{\text{return}}) + (\psi(n) - 1) \cdot (c_* + c_{\text{call}})$

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

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

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

หมายเหตุเกี่ยวกับค่าใช้จ่ายที่เชิงเส้นกำกับ

สิ่งที่คุณมักจะพบในวรรณกรรมและบนเว็บคือ "การวิเคราะห์ Big-Oh" คำที่เหมาะสมคือการวิเคราะห์เชิงเส้นกำกับซึ่งหมายความว่าแทนที่จะทำให้ได้ค่าใช้จ่ายที่แน่นอนตามที่เราทำในตัวอย่างคุณเพียงแค่ให้ค่าใช้จ่ายถึงปัจจัยคงที่และในขีด จำกัด (พูดโดยประมาณ "สำหรับใหญ่")$n$

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

นี่คือวิธีการวิเคราะห์เชิงความสัมพันธ์กับวิธีการนี้

1. ระบุการดำเนินการที่โดดเด่น (ที่ชักจูงต้นทุน) นั่นคือการดำเนินการที่เกิดขึ้นบ่อยที่สุด (สูงถึงปัจจัยคงที่) ในตัวอย่างของ Bubblesort หนึ่งทางเลือกที่เป็นไปได้คือการเปรียบเทียบในบรรทัดที่ 5

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

2. ทำการวิเคราะห์โดยใช้จำนวนการดำเนินการของการดำเนินการนี้เป็นต้นทุน
3. เมื่อลดความซับซ้อนให้ประมาณการ ใช้ความระมัดระวังเพื่อให้การประมาณการจากด้านบนหากเป้าหมายของคุณเป็นขอบเขตสูงสุด ( ) resp จากด้านล่างหากคุณต้องการลดขอบเขต ( )$O$$\Omega$

ให้แน่ใจว่าคุณเข้าใจความหมายของสัญลักษณ์กุ๊บ โปรดจำไว้ว่าขอบเขตดังกล่าวอยู่สำหรับทั้งสามกรณี ; การใช้ไม่ได้แปลว่าเป็นกรณีที่เลวร้ายที่สุด$O$

อ่านเพิ่มเติม

มีความท้าทายและลูกเล่นเพิ่มเติมในการวิเคราะห์อัลกอริทึม นี่คือคำแนะนำในการอ่าน

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

มีคำถามมากมายที่ติดแท็กการวิเคราะห์อัลกอริทึมโดยใช้เทคนิคที่คล้ายกับสิ่งนี้

การดำเนินการนับงบ

มีวิธีการอื่นที่ได้รับการสนับสนุนจาก Donald E. Knuth ในซีรี่ส์The Art of Computer Programming ตรงกันข้ามกับการแปลอัลกอริธึมทั้งหมดให้เป็นสูตรเดียวมันทำงานได้อย่างอิสระจากซีแมนทิกส์ของรหัสในด้าน "การรวมสิ่งต่าง ๆ เข้าด้วยกัน" และอนุญาตให้ไปในระดับต่ำกว่าเมื่อจำเป็นเท่านั้นโดยเริ่มจากมุมมอง "อินทรีอินทรี" ทุกคำสั่งสามารถวิเคราะห์ได้อย่างอิสระจากส่วนที่เหลือนำไปสู่การคำนวณที่ชัดเจนยิ่งขึ้น อย่างไรก็ตามเทคนิคการยืมรหัสตัวเองค่อนข้างดีรหัสหลอกระดับไม่สูง

วิธีการ

มันค่อนข้างง่ายในหลักการ:

1. กำหนดชื่อ / หมายเลขให้ทุกชุดคำสั่ง
2. กำหนดคำสั่งทุกค่าใช้จ่ายบางส่วนC_i$S_i$$C_i$
3. ตรวจสอบงบทุกจำนวนครั้งของการประหารชีวิตe_i$S_i$$e_i$

4. คำนวณค่าใช้จ่ายทั้งหมด

   $\qquad\displaystyle C = \sum_{i} e_i \cdot C_i$C_i

คุณสามารถแทรกการประมาณและ / หรือปริมาณเชิงสัญลักษณ์ ณ จุดใดก็ได้ การสรุปผลให้สอดคล้อง

โปรดทราบว่าขั้นตอนที่ 3 อาจซับซ้อนโดยพลการ ปกติแล้วคุณจะต้องทำงานกับ (asymptotic) การประมาณเช่น " " เพื่อรับผลลัพธ์$e_{77} \in O(n \log n)$

ตัวอย่าง: การค้นหาความลึกครั้งแรก

พิจารณาอัลกอริธึมกราฟการสำรวจเส้นทางต่อไปนี้:

dfs(G, s) do
  // assert G.nodes contains s
  visited = new Array[G.nodes.size]     1
  dfs_h(G, s, visited)                  2
end 

dfs_h(G, s, visited) do
  foo(s)                                3
  visited[s] = true                     4

  v = G.neighbours(s)                   5
  while ( v != nil ) do                 6
    if ( !visited[v] ) then             7
      dfs_h(G, v, visited)              8
    end
    v = v.next                          9
  end
end

เราคิดว่า (ไม่มีทิศทาง) กราฟจะได้รับจากรายการถ้อยคำบนโหน\} ให้เป็นจำนวนขอบ$\{0,\dots,n-1\}$$m$

เพียงแค่ดูที่อัลกอริทึมเราจะเห็นว่าคำสั่งบางคำสั่งถูกดำเนินการอย่างเท่าเทียมกันบ่อยครั้งเหมือนกับข้อความอื่น ๆ เราแนะนำตัวยึดตำแหน่ง ,และสำหรับการดำเนินการนับ :$A$$B$$C$$e_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & A & A & B & B & B & B+C & C & B-1 & C \end{array}$

โดยเฉพาะอย่างยิ่งเนื่องจากการเรียกซ้ำทั้งหมดในสาย 8 ทำให้เกิดการโทรในบรรทัดที่ 3 (และสายหนึ่งเกิดจากการโทรเดิม) นอกจากนี้เนื่องจากเงื่อนไขจะต้องมีการตรวจสอบหนึ่งครั้งต่อการทำซ้ำ แต่อีกครั้งเพื่อที่จะออกจากมัน$e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

เป็นที่ชัดเจนว่า 1 ตอนนี้ในระหว่างการพิสูจน์ความถูกต้องเราจะแสดงให้เห็นว่ามีการดำเนินการเพียงครั้งเดียวต่อโหนด ว่ามีที่n แต่จากนั้นเราจะวนซ้ำทุกรายการคำคุณศัพท์หนึ่งครั้งและทุกขอบหมายถึงสองรายการทั้งหมด (หนึ่งรายการสำหรับแต่ละโหนดของเหตุการณ์); เราได้รับการทำซ้ำโดยรวม เมื่อใช้สิ่งนี้เราจะได้รับตารางต่อไปนี้:$A=1$foo$B = n$$C = 2m$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & 1 & 1 & n & n & n & 2m + n & 2m & n-1 & 2m \end{array}$

สิ่งนี้ทำให้เรามีค่าใช้จ่ายทั้งหมดอย่างแน่นอน

$\qquad\begin{align*} C(n,m) = (C_1 + C_2 - C_8) &+\ n \cdot (C_3 + C_4 + C_5 + C_6 + C_8) \\ &+\ 2m \cdot (C_6 + C_7 + C_9) \;. \end{align*}$

ด้วยการทำให้ค่าที่เหมาะสมสำหรับนั้นสามารถทำให้เรามีต้นทุนที่เป็นรูปธรรมมากขึ้น ตัวอย่างเช่นหากเราต้องการนับการเข้าถึงหน่วยความจำ (ต่อคำ) เราจะใช้$C_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline C_i & n & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \end{array}$

และรับ

$\qquad\displaystyle C_{\text{mem}}(n,m) = 3n + 4m$4m

อ่านเพิ่มเติม

ดูที่ด้านล่างของคำตอบอื่น ๆ ของฉัน

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

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