Browse Books

Reviewer: I-Lun Tseng

What makes this book extraordinary is the fact that the author uses an alternative method to teach algorithms. Instead of explaining every detail of a procedure for solving a specific problem, the book teaches you how to use design strategies, or design techniques, to attack many different problems. This focus on developing problem solving skills is essential for those seeking to design new algorithms, as well as solve new problems. The book could be the result of an idea published by the author in a previous paper [1], in which the author suggests reclassifying algorithm design techniques. Ten algorithm design techniques (including brute force, divide-and-conquer, decrease-and-conquer, transform-and-conquer, space-time tradeoffs, dynamic programming, the greedy technique, iterative improvement, backtracking, and branch-and-bound) are included in the book. Each of the design techniques has a dedicated chapter, except for backtracking and branch-and-bound, which are put together in one chapter as ways to deal with difficult problems. The discussion of these ten design techniques constitutes the major part of the book. Chapter 1 briefly introduces algorithms and basic data structures. Chapter 2 presents fundamental techniques for the analysis of algorithms, along with examples. The mathematics used in the chapter has explicit steps, and is quite easy to understand. Chapter 3 introduces the most basic design strategy, brute force. Selection sort, bubble sort, and sequential search algorithms all fall into this category. Problems that can be solved by using the brute force strategy (such as the convex-hull, the traveling salesman, and the knapsack problems) are also presented. Chapter 4 discusses the divide-and-conquer technique. Algorithms such as merge sort, quicksort, and binary search are covered. Also, the idea of using divide-and-conquer in solving problems, such as the multiplication of large integers, Strassen's matrix multiplication, closest-pair, and convex-hull, is explained. Chapter 5 presents decrease-and-conquer algorithms, which include insertion sort, depth-first search (DFS), breadth-first search (BFS), topological sort, and many others. Permutation-generation and subset-generation algorithms are also presented; they can be applied in the brute force strategy, however the concepts of the algorithms fit into this chapter. The author did not clearly explain, however, why some of the other algorithms, such as DFS and BFS, belong to this design strategy. Chapter 6 introduces the transform-and-conquer technique. Each of the sections is easy to read and understand. The author, however, could have given clear reasons why Adelson-Velsky Landis (AVL) trees belong to "instance simplification" while 2-3 trees, heaps, and heapsort belong to "representation change." Chapters 7 through 10 discuss other design strategies, including space-time tradeoffs, dynamic programming, the greedy method, and iterative improvement. All of the chapters have a similar format: a brief introduction to the strategy, followed by its corresponding algorithms. Chapters 11 and 12 contain a lucid introduction to the theory of nondeterministic polynomial time (NP) completeness and approximation algorithms for some NP-hard problems. Backtracking and branch-and-bound are also presented, for tackling some difficult problems. The book is not only well structured, but also well organized. The algorithms presented in the book range from simple and straightforward (in the early chapters) to sophisticated and complex (in the later chapters), yet they all fit into the specific chapters in which they are presented. The book is intended for use as a textbook in a typical one-semester undergraduate course. In my opinion, the book serves its function quite well, since it covers the most basic, yet important, algorithm design and analysis techniques that an introductory algorithm course should contain. Online Computing Reviews Service