หลาย ๆ คนอาจรู้จักขั้นตอนวิธีแบ่งแยกเพื่อพิชิต (Divide & Conquer Algorithm) แล้ว ซึ่งก็คือ การนำปัญหาก้อนใหญ่ ๆ มาแบ่งออกเป็นก้อนเล็ก ๆ แล้วค่อย ๆ แก้ปัญหา เมื่อปัญหาก้อนเล็กถูกแก้แล้ว ก็จะนำมารวมให้ใหญ่ขึ้น จนสุดท้ายปัญหาก้อนใหญ่ ๆ นั้นก็จะสามารถแก้ไขได้สำเร็จ
แต่เราเชื่อว่า มีคนอีกไม่น้อยที่ไม่รู้จักขั้นตอนวิธีรวมรวมเพื่อพ่ายแพ้ (Multiply & Surrender Algorithm) เพราะว่าไม่มีในหลักสูตร (ซึ่งก็ไม่ควรมีอยู่แล้ว) ซึ่งก็คือ การนำปัญหาชิ้นเล็ก ๆ หลาย ๆ ก้อน มารวมกันเป็นก้อนใหญ่ ๆ ก้อนเดียว แล้วก็ค่อย ๆ แก้ปัญหา หรือไม่ก็ยอมแพ้ซะก่อนแก้ปัญหาได้สำเร็จ
เพื่อให้เห็นภาพมากขึ้น เราจะยกตัวอย่างด้วยภาษา JAVA เพราะว่าภาษานี้เหมาะกับการเขียนโปรแกรมเชิงวัตถุ (OOP)
// คลาสทุกสรรพสิ่ง
public static class ClassOfEverything {
private static ClassOfEverything CoE1;
private static ClassOfEverything CoE2;
private static ClassOfEverything CoE3;
// ... ฟิลด์ทุกสรรพสิ่ง
/// ฟังก์ชันทุกสรรพสิ่ง
public final ClassOfEverything functionOfEverything(ClassOfEverything... params) {
// ... โค้ดที่สามารถทำได้ทุกสรรพสิ่ง
return returnOfEverything;
}
}
ถ้าจะใช้ขั้นตอนวิธีนี้จริง ๆ เช่นเพื่อทดสอบความอดทนของตัวผู้พัฒนาซอฟต์แวร์ ไม่ก็ทดสอบประสิทธิภาพของตัวฮาร์ดแวร์ ควรพยายามให้โปรแกรมมีเพียงแค่คลาสเดียวและในคลาสนั้นมีฟังก์ชันเดียวเท่านั้น เพื่อให้สามารถประยุกต์ใช้ขั้นตอนวิธีรวบรวมเพื่อพ่ายแพ้ได้มากที่สุด
อ้างอิง:
Bentley, J. L., Haken, D., & Saxe, J. B. (1980). A general method for solving divide-and-conquer recurrences.
ACM SIGACT News, 12(3), 36–44. Retrieved by
ลิงก์นี้.
เปเปอร์นี้เกี่ยวกับขั้นตอนวิธีแบ่งแยกเพื่อพิชิต
Broder, A., & Stolfi, J. (1984). Pessimal Algorithms and Simplexity Analysis.
ACM SIGACT News, 16(3), 49–53. Retrieved by
ลิงก์นี้ (เอกสารได้มาจากการกด Download full-text PDF).
เปเปอร์นี้เกี่ยวกับขั้นตอนวิธีรวมรวมเพื่อพ่ายแพ้ (เป็นมุกทางวิชาการ แต่ก็ไม่น่าเชื่อว่ามีคน cite เปเปอร์ดังกล่าวนี้ด้วย) 
ขั้นตอนวิธีรวมรวมเพื่อพ่ายแพ้ (Multiply & Surrender Algorithm) กับการ(ไม่ควร)ประยุกต์ใช้
แต่เราเชื่อว่า มีคนอีกไม่น้อยที่ไม่รู้จักขั้นตอนวิธีรวมรวมเพื่อพ่ายแพ้ (Multiply & Surrender Algorithm) เพราะว่าไม่มีในหลักสูตร (ซึ่งก็ไม่ควรมีอยู่แล้ว) ซึ่งก็คือ การนำปัญหาชิ้นเล็ก ๆ หลาย ๆ ก้อน มารวมกันเป็นก้อนใหญ่ ๆ ก้อนเดียว แล้วก็ค่อย ๆ แก้ปัญหา หรือไม่ก็ยอมแพ้ซะก่อนแก้ปัญหาได้สำเร็จ
เพื่อให้เห็นภาพมากขึ้น เราจะยกตัวอย่างด้วยภาษา JAVA เพราะว่าภาษานี้เหมาะกับการเขียนโปรแกรมเชิงวัตถุ (OOP)
public static class ClassOfEverything {
private static ClassOfEverything CoE1;
private static ClassOfEverything CoE2;
private static ClassOfEverything CoE3;
// ... ฟิลด์ทุกสรรพสิ่ง
/// ฟังก์ชันทุกสรรพสิ่ง
public final ClassOfEverything functionOfEverything(ClassOfEverything... params) {
// ... โค้ดที่สามารถทำได้ทุกสรรพสิ่ง
return returnOfEverything;
}
}
ถ้าจะใช้ขั้นตอนวิธีนี้จริง ๆ เช่นเพื่อทดสอบความอดทนของตัวผู้พัฒนาซอฟต์แวร์ ไม่ก็ทดสอบประสิทธิภาพของตัวฮาร์ดแวร์ ควรพยายามให้โปรแกรมมีเพียงแค่คลาสเดียวและในคลาสนั้นมีฟังก์ชันเดียวเท่านั้น เพื่อให้สามารถประยุกต์ใช้ขั้นตอนวิธีรวบรวมเพื่อพ่ายแพ้ได้มากที่สุด
อ้างอิง:
Bentley, J. L., Haken, D., & Saxe, J. B. (1980). A general method for solving divide-and-conquer recurrences. ACM SIGACT News, 12(3), 36–44. Retrieved by ลิงก์นี้.
เปเปอร์นี้เกี่ยวกับขั้นตอนวิธีแบ่งแยกเพื่อพิชิต
Broder, A., & Stolfi, J. (1984). Pessimal Algorithms and Simplexity Analysis. ACM SIGACT News, 16(3), 49–53. Retrieved by ลิงก์นี้ (เอกสารได้มาจากการกด Download full-text PDF).
เปเปอร์นี้เกี่ยวกับขั้นตอนวิธีรวมรวมเพื่อพ่ายแพ้ (เป็นมุกทางวิชาการ แต่ก็ไม่น่าเชื่อว่ามีคน cite เปเปอร์ดังกล่าวนี้ด้วย)