After the O(log n)-approximation algorithms for Asymmetric TSP, the first algorithm to beat the cycle cover algorithm by more than a constant factor was found in 2009 by Asadpour, Goemans, Mądry, Oveis Gharan, and Saberi. Their approach is based on finding a "thin" (oriented) spanning tree and then adding edges to obtain a tour. A major open question is how thin trees are guaranteed to exist.

The O(log n/loglog n)-approximation algorithm by Asadpour et al. samples a random spanning tree from the maximum entropy distribution. To show how this works, we discuss interesting connections between random spanning trees and electrical networks. Some results of this chapter will be used again in Chapters 10 and 11.

This chapter is about the proof of the main payment theorem for hierarchies by Karlin, Klein, and Oveis Gharan, a key piece of their better-than-3/2-approximation algorithm for Symmetric TSP. Because the proof is very long and technical, we will not give a complete proof here but rather focus on explaining the key combinatorial ideas.

This chapter is structured as follows. First, we describe the general proof strategy and prove the theorem in an idealized setting. Then we discuss a few crucial properties of λ-uniform distributions. The following sections focus on the main ideas needed to address the hurdles we ignored in the idealized setting described initially.

Finally, we show how the Karlin–Klein–Oveis Gharan algorithm can be derandomized.

In this chapter and Chapter 8, we describe a constant-factor approximation algorithm for the Asymmetric TSP. Such an algorithm was first devised by Svensson, Tarnawski, and Végh. We present the improved version by Traub and Vygen, with an additional improvement that has not been published before.

The overall algorithm consists of four main components, three of which we will present in this chapter. First, we show that we can restrict attention to instances whose cost function is given by a solution to the dual LP with laminar support and an additional strong connectivity property. Second, we reduce such instances to so-called vertebrate pairs. Third, we will adapt Svensson’s algorithm from Chapter 6 to deal with vertebrate pairs. The remaining piece, an algorithm for subtour cover, will be presented in Chapter 8.

By combining the removable pairing technique presented in Chapter 12 with a new approach based on ear-decompositions and matroid intersection, Sebő and Vygen improved the approximation ratio for Graph TSP from 13/9 to 7/5. We will present this algorithm, which is still the best-known approximation algorithm for Graph TSP, in this chapter.

An interesting feature of this algorithm is that it is purely combinatorial, does not need to solve a linear program, and runs in O(n3) time. To describe the algorithm, we review some matching theory, including a theorem of Frank that links ear-decompositions to T-joins. A slight variant of the Graph TSP algorithm is a 4/3-approximation algorithm for finding a smallest 2-edge-connected spanning subgraph, which was the best known for many years. The proofs will also imply corresponding upper bounds on the integrality ratios.

Java is one of the world’s most popular programming languages. Widely used in enterprise software development, Java’s strengths lie in its combination of performance and portability, as well as its large, robust library of built-in features, which allow developers to create complex applications entirely within the language. Java was developed in the early 1990s by a team from Sun Microsystems led by James Gosling. Initially called Oak (after a tree outside Gosling’s office), the new language was intended to be a development environment for interactive TV, but pivoted to the emerging World Wide Web after its public release in 1995. Since then, Java has expanded into almost every area of software development. It is the default programming language for Android mobile devices, the Hadoop large-scale data processing system, and Minecraft. Java is one of the most well-known object-oriented programming languages.

This chapter surveys the core elements of Java programming, assuming some familiarity with programming in any language. If you already have Java experience, it will be a refresher on important points. If your experience is with Python, JavaScript, or other languages, this chapter will help you understand how Java does things differently.

After the linear data structures and hash tables, we’re now ready to introduce the third major kind of structure: trees, which represent hierarchical data. Computer science, like nature, delights in trees: There are a huge number of tree-based structures customized for different problems. In particular, trees are used to construct map data structures that provide useful alternatives to hash tables.

A heap is a tree-based data structure that’s designed to quickly return the maximum or minimum of its items. Like a search tree, it maintains a special ordering among its nodes, and takes advantage of the hierarchical nature of binary trees to perform its operations in O(log n) time. Heaps are the primary implementation of the priority queue abstract data type. Like the first-in-first-out queues we studied in Chapter 13, a priority queue supports operations to insert and remove elements, but also maintains an ordering among its items. Polling the queue returns the next item according to the underlying ordering, rather than strictly returning items in FIFO order. Priority queues are used in applications that need to continually fetch the “next” item of a dynamic set that may change over time. A common application is ordering events by time in a simulation program.

Seymour Papert published Mindstorms in 1980. Subtitled Children, Computers, and Powerful Ideas, the book advocated for making computational thinking a core part of the curriculum for young children (Papert, 1980). Mindstorms was influential in computer education circles, and the approaches it described were the first exposure to programming and computer science for many children. LEGO later adopted the name for a line of programmable building sets.

The previous two chapters introduced hash functions and hash tables. In this chapter, we’ll combine hash tables with lists to construct a search engine index. Our index will map a search word to the list of locations where that word occurs in a set of text documents. The data for our example search engine will come from the plays of William Shakespeare, the most influential English-language dramatist in history. We’ll work primarily with the text of Macbeth. The play provides a good development example because the text is rich enough to be interesting, but the structured script format makes it easy to extract everything we need with a reasonable amount of code.

The stack is the Incredible Hulk of data structures: superficially dumb, but so strong that it doesn’t matter. Stacks have only a few basic operations and they’re easy to implement, but they unlock a number of algorithms that are both theoretically powerful and practically important. You may recall that we previously discussed the role of the stack in recursion, and there’s a connection between the stack as an explicit data structure and recursive methods that use a stack implicitly.