usaco-guide/content/4_Silver/Intro_Sorting.md

id	title	author
intro-sorting	Introduction to Sorting	Siyong Huang, Michael Cao, Nathan Chen

Introduces sorting, binary search, coordinate compression.

Sorting is exactly what it sounds like: arranging items in some particular order.

Additional Resources

• CPH 3 (once again, very good)

Sorting Algorithms

(why are these important?)

There are many sorting algorithms, here are some sources to learn about the popular ones:

• Bubble Sort
  • Out of Sorts (Silver)
    • hard!
• Quicksort
• Mergesort

Library Sorting

• C++:
  • std::sort Documentation
  • C++ Tricks (First Two Related To Sorting)
  • std::stable_sort documentation
• Java:
  • Arrays.sort Documentation
  • Breaking Java Arrays.sort()
    • no longer works, but see this one instead.
    • to avoid getting hacked, shuffle the array beforehand.
• Python:
  • Sorted Documentation

Binary Search

Binary search can be used on monotonic (what's that?) functions for a logarithmic runtime.

Here is a very basic form of binary search:

Find an element in a sorted array of size N in O(\log N) time.

Other variations are similar, such as the following:

Given K, find the largest element less than K in a sorted array.

Tutorial

• CSES 3.3
• CSAcademy Binary Search
• Topcoder Binary Search
• KhanAcademy Binary Search
• GeeksForGeeks

Library Functions to do Binary Search

Java

• Arrays.binarySearch
• Collections.binarySearch

C++

• lower_bound
• upper_bound

Example (Coordinate Compression)

Another useful application of sorting is coordinate compression, which takes some points and reassigns them to remove wasted space. Let's consider the USACO Silver problem Counting Haybales:

Farmer John has just arranged his N haybales (1\le N \le 100,000) at various points along the one-dimensional road running across his farm. To make sure they are spaced out appropriately, please help him answer Q queries (1 \le Q \le 100,000), each asking for the number of haybales within a specific interval along the road.

However, each of the points are in the range 0 \ldots 1,000,000,000, meaning you can't store locations of haybales in, for instance, a boolean array. However, let's place all of the locations of the haybales into a list and sort it.

(fix this part)

Now, we can map distinct points to smaller integers without gaps. For example, if the haybales existed at positions [1, 4, 5, 9] and queries were (1, 2) and (4, 6), we can place the integers together and map them from [1, 2, 4, 5, 6, 9] \rightarrow [1, 2, 3, 4, 5, 6]. This effectively transforms the haybale positions into [1, 3, 4, 6] and the queries into 1, 2 and 3, 5.

By compressing queries and haybale positions, we've transformed the range of points to 0 \ldots N + 2Q, allowing us to store prefix sums to effectively query for the number of haybales in a range.