This 495-page book is devoted to working through 200 problems from the ACM International Collegiate Programming Contest. The problems are selected from competitions held between 1990 and 2015. The book has been translated from the original Chinese publication, and it is the second book in a three-book series written by the authors.

The authors believe that the success of programming competition contestants is based on their knowledge of programming and strategies applicable to solving problems, but so too is the success of a computer science student in general. Their assertion is that the book is an aid to all computer science students in terms of developing programming skills through practice and also enhancing their ability to solve these problems through appropriate strategies and selection of data structures.

The book is divided into four sections. Section 1 deals with fundamental problems that are relatively simple and involve straightforward solutions, simple simulation, or simple recursive solutions, which the authors claim are suitable for students still engaged in learning a programming language. Section 2 focuses on problems that utilize a linear list in their solution. Section 3 focuses on trees and, finally, Section 4 deals with tree-based solutions. Each section opens with a short description of the kinds of problems and solution spaces addressed by the sections, and concludes with a short summary. Each section is broken into chapters focusing on one major topic identified in the opening page of the section.

Section 1 deals with problems the authors deem to be fundamental, straightforward, and suitable to someone learning a programming language. Chapter 1 deals with introducing the reader to the structure and nature of programming competitions and covers fundamental problems. Chapter 2 turns its attention to simple simulations, and the section concludes with chapter 3, which addresses basic recursion. Students new to programming and not familiar with the entire programming language they are working in (solutions are provided in C++) will struggle with this section. Some of the problems require knowledge of mathematics beyond the typical knowledge base of a freshman college student.

Section 2 is focused on linear lists. Chapter 4 deals with direct access lists, chapter 5 deals with sequential access, chapter 6 deals with generalized lists with indices, and the section concludes with chapter 7 addressing sorting.

Section 3 is concerned with trees. Chapter 8 is devoted to basic tree algorithms, chapter 9 addresses binary trees, and chapter 10 closes the section with its focus on problems focused on heaps and other classical tree-based solutions.

Finally, Section 4 deals with graphs. Chapter 11 opens with the application of basic graph traversal algorithms, and chapter 12 deals with minimal spanning trees. Chapter 13 covers various pathways through graphs (Warshall’s, Dijkstra’s, and Bellman-Ford’s algorithms are all covered), before concluding with chapter 14, which addresses bipartite graphs and flow networks.

There is little discussion in each chapter with the primary aim of the authors being the description of the problem and the presentation of the sample input/output. For many problems, this is followed by an analysis of the problem and a sample solution written in C++. However, after the first 50 pages, the solutions are sometimes omitted with the analysis serving as the guide to the reader for implementation purposes; as the reader moves through the book, the analysis is increasing replaced with hints to a solution. Although it is not explicitly stated, it is likely that this is the authors’ methodology to have the reader become increasingly challenged and simultaneously left to semi-independently solve the problem.

There are many websites that allow students to find problems from previous programming competitions (for example, https://open.kattis.com/) and many sites where solutions to problems may be found. This book offers some benefit in that it opens with several samples that show students how to think about the competition problems and ways to go about solving them. The book does not provide a strategy to succeed at programming competitions other than through practice. Because the latter parts of the book do not always provide the reader with a solution, the book starts to lose its value, and interested students can easily find their own problems to work on.

In the preface, the authors stated their belief that the programming and problem-solving experience in competitions was valuable to all computer science students. Sadly, the book does not address this cadre of students beyond its preface. Had the authors explicitly addressed this group and provided strategies for solving challenges through an analysis of the problem and appropriate choice of data structure, and had the authors shown the reader where these somewhat contrived problems had applicability to real-world problems, the book would have been far more valuable to the reader.