ปัญหาการทอนเหรียญ
คนขายของผู้หนึ่งเปิดร้าน ขายของจิปาถะเล็ก ๆ เมื่อลูกค้าเข้ามาในร้านและซื้อสินค้าจากร้าน ลูกค้ามักจะให้จำนวนเงินเป็นธนบัตรซึ่งมากกว่าราคาสินค้าจริง คนขายของต้องทอนเงินให้กับลูกค้า โดยทอนเป็นเหรียญ กำหนดว่าเหรียญมีอยู่ห้าประเภทคือ เหรียญ dollar (มีค่า 100), เหรียญ quarter (มีค่า 25), เหรียญ dime (มีค่า 10), เหรียญ nickel (มีค่า 5) และเหรียญ penny (มีค่า 1) ถ้าเขาต้องทอน x เขาจะให้เหรียญอย่างใดเท่าไร จึงจะมีจำนวนเหรียญที่ทอนให้น้อยที่สุด
ตัวอย่างเช่น $2.89 = 2 ของเหรียญ dollar + 3 ของเหรียญ quarter + 1 ของเหรียญ dime + 4 ของเหรียญ penny
MAKE-CHANGE(y)
ข้อมูลเข้า y เป็นจำนวนเต็มบวกหรือศูนย์
ข้อมูลออก (x5, x4, x3, x2, x1) เมื่อ x5 แทนจำนวนเหรียญ dollar, x4 แทนจำนวนเหรียญ quarter, x3 แทนจำนวนเหรียญ dime, x2 แทนจำนวนเหรียญ nickel, x1 แทนจำนวนเหรียญ penny
โดยที่ x1, x2, x3, x4, x5 เป็นจำนวนเต็มบวกที่มากกว่าหรือเท่ากับศูนย์

1.  C = (100, 25, 10, 5, 1);
2.  x = (0,0,0,0,0);
3.  sum = 0;
4.  while sum != y do
5.     i = largest in C such that sum + C[i]   y
6.     if there is no such item then return "No solution";
7.    (sum, x[i]) = (sum+C[i], x[i]+1);
8.  endwhile
9.  return x

1. S = Ø
2. while C != Ø and not solution(S) do
3.    x = select(C)
4.    C = C - {x}
5.    if feasible(S  {x}) then S = S  {x}
6. endwhile
7. if solution(S) then return S else return "No solution"

ปัญหา Activity-selection problem
สมมุติว่าเรามีเซต S = {1, ..., n} เป็นเซตของ n activities ซึ่งต้องการใช้เครื่องจักรกลางในการประมวลผลขณะเวลาใด ๆ โดยที่เครื่องจักรนี้ประมวลผลทีละ 1 activity ในขณะใด ๆ นั้นคือ ถ้า activity i ถูกประมวลผลอยู่แล้ว เราไม่สามารถประมวลผล activity อื่น ๆ ได้ สำหรับทุก activity i กำหนด s_i และ f_i เป็นเวลาเริ่มต้นและเวลาสิ้นสุดในการประมวลผล โดยที่ s_i f_i ในรูปแบบของ [s_i, f_j)
เราเรียก i ว่าเข้ากับ j (compatible with j) ถ้า [s_i, f_i) ไม่มีช่วงที่ร่วมกันกับ [s_j, f_j) นั้นคือ s_i f_j หรือ s_j f_i ดังนั้นปัญหา activity-selection คือการเลือกจำนวนของ activity ให้มากที่สุดจาก S โดยที่แต่ละ activity นั้นเข้ากันได้ทั้งหมด
สมมติว่าข้อมูลที่เข้ามีการเรียง f₁ f₂ f₃ ... f_n.
ACTIVITY-SELECTOR(s, f)
ข้อมูลเข้า s และ f เป็น array ของจำนวนจริงบวกขนาด n โดยที่ s_i f_i ทุก i
ข้อมูลออก A เป็น stack ซึ่งเก็บดรรชนีของ activity ที่เลือก

1.  n = length(s)
2.  push(A, 1)
3.  j = 1
4.  for i = 2 to n do
5.     if si   fj then
6.        push(A, i)
7.        j = i
8.  return A

การพิสูจน์ความถูกต้องของ ACTIVITY-SELECTOR
ทฤษฎี ขั้นตอนวิธี ACTIVITY-SELECTOR ส่งคำตอบที่เลือกจำนวนของ activity ที่มากที่สุดใน S โดยที่แต่ละ activity นั้นเข้ากันได้ทั้งหมด
พิสูจน์

1. กำหนดให้ S = {1, 2, ..., n} โดยที่ ลำดับเรียงตาม f_i
2. เราต้องการจะแสดงว่าคำตอบที่เหมาะที่สุดมีอยู่หนึ่งคำตอบที่มี activity 1 อยู่ในเซตของคำตอบเสมอ
   สมมติว่า A เป็นคำตอบที่เหมาะที่สุดของ S ที่กำหนดให้ เราสามารถสมมติโดยไม่เสียนัยว่า activity ใน A มีการเรียงลำดับของ f_j จากน้อยไปมาก
   สมมติ activity แรกของ A เป็น k ถ้า k = 1 เราได้คำตอบอย่างที่ต้องการ
   ถ้าไม่ใช่ เราต้องได้ f₁ f_k ดังนั้นเซตใหม่ที่เรากำหนดโดยตัด k ทิ้ง และเติม 1 เข้าไปจะเป็นคำตอบที่เหมาะที่สุดด้วย เพราะว่าจำนวนของ activity เท่ากับ A (B = (A - {k}) {1})
   นั้นคือเราแสดงว่าจะมีคำตอบที่เหมาะที่สุดซึ่งมี activity 1 อยู่เสมอ

บทแทรก หลังจากเราเลือก 1 แล้วเราจะได้ว่าปัญหาที่เหลืออยู่จะเป็นปัญหา activity-selection ซึ่งมีขนาดเล็กลง โดยที่ S ใหม่คือเซตของ activity ที่มี s_i s₁ โดยใช้ induction เราจะได้ว่าคำตอบที่ได้จาก ACTIVITY-SELECTOR เป็นคำตอบที่เหมาะสมที่สุดตามต้องการ

ปัญหาการเลือกของ Knapsack problem โดยวิธีแบ่งส่วน
กำหนดให้มีของอยู่ n ประเภทและถุงอยู่หนึ่งถุง โดยที่ของประเภทที่ i มีน้ำหนักทั้งหมด w_i อยู่ พร้อมค่า v_i เราไม่สามารถบรรทุกของเกิน W หน่วย เราต้องการเติมถุงนี้ให้เต็มโดยที่มีค่าผลรวมของ v_i สูงที่สุดและน้ำหนักไม่เกินค่า W ที่กำหนด
เราสามารถเขียนปัญหาให้อยู่ในรูปของ Optimization problem ดังนี้

Maximize x_i v_i

subject to x_i w_i W

          0 x_i 1

1.  for i = 1 to n
2.    x[i] = 0
3.  weight = 0
4.  while weight < W do
5.     i = the best remaining object
6.     if weight + w[i]  W then
7.                   x[i] = 1; weight = weight + w[i]
8.     endif
9.  endwhile
10. If weight != W then
11.    i = the best remaining object
12.    x[i] = (W-weight)/w[i]
13. endif
14.  return x

ปัญหาการบริการลูกค้าให้มีเวลาในการรอน้อยที่สุด
กำหนดให้มีผู้บริการอยู่หนึ่งคน และมีลูกค้าอยู่ n คนโดยที่ เราทราบเวลาในการใช้บริการของลูกค้าแต่ละคนคือ t₁, ..., t_n เราต้องการหาเวลารวมในการรอที่น้อยที่สุดที่ลูกค้าต้องเสียไปในระหว่างรอรับบริการ จนรับบริการเสร็จ
ตัวอย่างเช่น เรามีลูกค้าอยู่สามคน โดยที่ t₁ = 5, t₂ = 10, t₃ = 3 จงหาว่าเราต้องบริการลูกค้าอย่างไร จึงทำให้ผลรวมในการรอทั้งหมดน้อยที่สุด

ปัญหาการจัดตารางงานเมื่อมี deadline
เรามีงานอยู่ทั้งหมด n งานที่ใช้เวลาหนึ่งหน่วยในการทำ โดยที่ขณะเวลาใด ๆ เราสามารถทำงานได้เพียงงานเดียว กำหนดว่า งาน i ให้ผลตอบแทน g_i > 0 ก็ต่อเมื่อ งานนี้เสร็จไม่ช้าไปกว่าเวลา d_i เราควรเลือกทำงานใด เมื่อไร เพื่อให้ได้ผลตอบแทนรวมสูงที่สุด
ตัวอย่างเช่น เรามีงาน 4 ชิ้นที่มีค่าตอบแทน 50, 10, 15, 30 และเวลาส่ง 2, 1, 2, 1 ตามลำดับ

ปัญหาการหา Minimum spanning tree
กำหนด G = < V, E > เป็นกราฟเชื่อมโยงซึ่งไม่มีทิศทาง เมื่อ V เป็นเซตของจุดยอด และ E เป็นเชตของด้าน โดยกำหนดให้แต่ละด้านมีความยาวเป็นจำนวนเต็มบวก จงหาสับเซต T ของ E ซึ่งทำให้ทุกจุดยอดเชื่อมโยงกันและมีค่าผลรวมของทุกด้านน้อยที่สุด

1. เนื่องจาก G เชื่อมโยงเราจะมี Minimum spanning tree เสมอ
2. สำหรับกราฟเชื่อมโยงที่มี n จุดยอดต้องมีด้านมากกว่าหรือเท่ากับ n-1 เสมอ
3. สำหรับกราฟที่มี n จุดยอดและมี n ด้านจะมี cycle ในกราฟนี้เสมอ
4. ถ้า T มีจำนวนด้าน n-1 และสับกราฟ G เชื่อมโยง แล้วจะได้ว่า สับกราฟนี้คือต้นไม้

Huffman codes
เป็นขั้นตอนวิธีการลดขนาดของข้อมูลที่มีจำนวนมากโดยที่สามารถนำข้อมูลแปลงกลับมาในสภาพที่เหมือนเดิมได้ โดยปกติสามารถลดขนาดของข้อมูลได้ 20% ถึง 90% หลักการคือการใช้ตารางความถี่การปรากฎของแต่ละตัวอักขระ เพื่อหาวิธีการแทนที่ตัวหนังสือที่น้อยที่สุดโดยใช้ binary string
ถ้าเรามี 100,000 ตัวอักขระของข้อมูลโดยที่มีตัวอักขระที่ปรากฎอยู่ 6 ตัวเราจะได้ว่าโดยประมาณแล้วตัวอักขระ แต่ละตัวจะปรากฎอยู่ 16667 ครั้ง ถ้าตัวอักขระแต่ละตัวใช้ fixed length code เราต้องใช้ 3 บิต ในการแทนที่ ตัวอักขระ 6 ตัว ดังนั้นจำนวนบิตทั้งหมดที่ต้องการ 300,000 บิต เช่น

Prefix code
Prefix code คือการกำหนด code โดยที่รหัสที่ใช้แต่ละค่าไม่มีรหัสข้างหน้า (prefix) ซ้ำกับรหัสของ code อื่น ๆ
การสร้างข้อมูลโดยใช้รหัสที่กำหนด (encoding) สามารถทำได้โดยง่ายเมื่อทราบ prefix code นั่นคือเราแทนแต่ละ ตัวอักขระด้วย code ที่กำหนดเขียนเรียงต่อกันจนจบเช่น abc แทนด้วย 0101100
ในทำนองเดียวกันการแปลงรหัสกลับ (decoding) สามารถทำได้ง่ายเมื่อทราบ prefix code เนื่องจากตัวอักขระทุกตัวไม่มีรหัสซ้ำกันข้างหน้า ดังนั้นตัวอักขระจะไม่มีความกำกวม เราเพียงแค่จับคู่บิตกับรหัสที่มี เช่น 001011101 คือ aabe
เรานิยมใช้ binary tree ในการกำหนด prefix code โดยที่ leaf คือตัวอักขระ และ internal node แทนด้วยจำนวนข้อมูลที่สร้างต้นไม้ สำหรับแต่ละกิ่งจะแทนด้วย 0 หรือ 1 ซึ่งหมายถึงบิตที่จะใช้แทนรหัสของตัวอักขระโดยจะเรียงจาก root มายัง leaf

การสร้าง Huffman code tree
กำหนด tree ซึ่งแทน prefix code เราสามารถคำนวณจำนวนบิตที่ต้องใช้คือ
B(T) = f(c) d(c, T)
เมื่อ f(c) แทนจำนวนความถี่ของตัวอักขระ c และ d(c, T) คือความสูงของตัวอักขระ c ใน T เราจะใช้ค่า B(T) เป็นค่า cost ของต้นไม้ tree
Huffman code algorithm สร้างต้นไม้ซึ่งเป็น optimal prefix code
HUFFMAN-TREE(C, v)
ข้อมูลเข้า C เป็นเซตของตัวอักขระ n ตัว และ v เป็นจำนวนความถี่ของตัวอักขระแต่ละค่า
ข้อมูลออก รากของต้นไม้ prefix code

1. n = | C |
2. Q = C used v as a keyed
3.  for i = 1 to n-1 do
4.     z = ALLOCATE-NODE()
5.     x = left[z] = Extract-Min(Q)
6.     y = right[z] = Extract-Min(Q)
7.    v[z] = v[x] + v[y]
8.    Insert(Q, z)
9. return Extract-Min(Q)

การพิสูจน์ความถูกต้องของ Huffman code tree
ทฤษฎีย่อย กำหนด C เป็นเซตของตัวอักขระที่ปรากฎทั้งหมดและ v เป็นฟังก์ชันความถี่ของตัวอักขระแต่ละตัว c ใน C ถ้า x และ y เป็นตัวอักขระสองตัวใน C ที่มีความถี่น้อยที่สุดในขณะนั้น แล้ว จะมี optimal prefix code ของ C สำหรับ x และ y ซึ่งมีขนาดเท่ากับ x, y แต่ต่างกันที่บิตสุดท้าย
พิสูจน์ เราจะใช้หลักการที่ว่าสำหรับ Tree ที่ optimal tree เราจะสร้าง Huffman code tree ที่ optimal ที่มี x และ y ปรากฎเป็น sibling leaves ที่มี maximum depth
กำหนดให้ b และ c เป็น sibling สองตัวที่มี maximum depth ใน T เราสามารถสมมติโดยไม่เสียนัยว่า v[b] v[c] และ v[x] v[y] จากการที่ v[x] และ v[y] เป็นความถี่ที่น้อยที่สุดจะได้ว่า v[x] v[b] และ v[y] v[c] ดังรูป

ขั้นแรก เราเปลี่ยนจาก T' เป็น T โดยสลับที่ระหว่าง b กับ x
ขั้นที่สอง เราเปลี่ยนจาก T' เป็น T" โดยสลับที่ระหว่าง c กับ y
เราจะได้
และในทำนองเดียวกัน เราจะได้ B(T') - B(T") 0 เราจะได้ว่า B(T") B(T) แต่ T เป็น optimal tree ดังนั้น T" เป็น optimal tree ด้วย
ทฤษฎีย่อย ให้ T เป็น binary tree ซึ่งแทน optimal prefix code สำหรับ C และ v เป็นฟังก์ชันความถี่ของ C สำหรับตัวอักขระสองตัว x และ y ซึ่งเป็น sibling leaves ของ T ที่มี z เป็น parent, ถ้า v[z] = v[x] + v[y] แล้วต้นไม้ T' = T - {x,y} เป็น optimal prefix code ของ C' = C - {X, y} {z}
พิสูจน์ เนื่องจาก d(c, T) = d(c, T') ทุก c ใน C - {x, y} เราจะได้ v[c]d(c, T) = v[c] d(c, T')
เพราะว่า d(x, T) = d(y, T) = d(z, T') + 1 เราจะได้
v[x] d(x, T) + v[y] d(y, T) = (v[x] + v[y])(d(z, T') + 1) = v[z] d(z, T') + (v[x] + v[y]) ทำให้ได้ว่า B(T) = B(T') + v[x] + v[y]
ถ้า T' ไม่ใช่ optimal prefix code tree สำหรับ C' แล้วจะมี prefix code tree T" ซึ่ง B(T") B(T') เนื่องจาก z เป็นตัวอักขระตัวหนึ่งใน C' ดังนั้น z ต้องเป็น leaf หนึ่งใน T" และเมื่อเราเติม x และ y ลงไปเป็น children ของ z ใน T" เราจะได้ว่า prefix code ของ C จะมี cost เป็น B(T") + v[x] + v[y] < B(T) เกิดการขัดแย้งกับ optimality ของ T
ดังนั้นจะต้องได้ว่า T' ต้องเป็น optimal prefix code ของ C'