How to add your own solutions to the guide.

Adding Solutions

How to identify errors within your program or avoid them in the first place.

Basic Debugging

What languages you can use for programming contests.

Choosing a Language

General ideas on how to strategize during a USACO contest.

Contest Strategy

Well-known programming contests and helpful tools for programming contests.

Contests

Contributing

OS-specific instructions for installing and running C++ via the command line.

C++ With the Command Line

The data types needed for competitive programming.

Data Types

What to do when your solution doesn't work.

How to Debug

Debugging C++

What you're expected to know before continuing onto the rest of USACO Bronze.

Expected Knowledge

Demonstrates how I/O speed can be the difference between TLE and AC.

Fast Input & Output

Writing code that can easily be reused or extended.

(Optional) C++ - Writing Generic Code

How to read input and print output for USACO contests.

Input & Output

Programming competitions, including the USA Computing Olympiad.

Introduction to Competitive Programming

(Optional) C++ - Lambda Expressions

Resources: Learning to Code

Introducing Modules

Major (inter)national olympiads in informatics.

Olympiads

How to practice and when to read editorials (analyses) according to various USACO competitors.

How to Practice

Helpful links specifically for competitive programming.

Resources: Competitive Programming

Resources specifically for the United States.

Resources: USA-Specific

Options for running your language of choice locally.

Running Code Locally

Options for running your language of choice online.

Running Code Online

Relevant links (and more) regarding USACO Camp qualification.

USACO Camp

Answers to frequently asked questions about the USA Computing Olympiad.

USACO FAQs

A table with all recent USACO Monthly Problems.

USACO Monthlies

How to effectively use this guide to maximize your productivity.

Using This Guide

Explanation of the frontmatter that precedes every module and solution, and a list of custom components that may be used within modules or solutions.

Working With MDX

Problems that do not fall into standard categories with well-studied solutions.

Ad Hoc Problems

Dividing into multiple cases and solving for each one separately.

Casework

Harder problems involving iterating through the entire solution space, including those that require generating subsets and permutations.

Complete Search with Recursion

Final tips for Bronze and additional practice problems.

Additional Practice for USACO Bronze

Problems involving iterating through the entire solution space.

Basic Complete Search

What a data structure is, (dynamic) arrays, pairs, and tuples.

Introduction to Data Structures

Introduction to Graphs

Problems that can be solved by selecting the choice that seems to be the best at the moment at every step.

Introduction to Greedy Algorithms

Maintaining collections of distinct elements/keys with sets and maps.

Introduction to Sets & Maps

Arranging collections in increasing order.

Introduction to Sorting

Problems involving rectangles whose sides are parallel to the coordinate axes.

Rectangle Geometry

Directly simulating the problem statement.

Simulation

Measuring the number of operations an algorithm performs.

Time Complexity

Binary searching on arbitrary monotonic functions.

Binary Search

Efficiently searching for a value in a sorted array.

Binary Search on a Sorted Array

Final tips for Silver and additional practice problems.

Additional Practice for USACO Silver

Finding connected components in a graph represented by a grid.

Flood Fill

Directed graphs in which every vertex has exactly one outgoing edge.

Introduction to Functional Graphs

Traversing a graph with depth first search and breadth first search.

Graph Traversal

Solving greedy problems by sorting the input.

Greedy Algorithms with Sorting

Six bitwise operators and the common ways they are used.

Intro to Bitwise Operators

Introducing a special type of graph: trees.

Introduction to Tree Algorithms

Max subarray sum, prefix sums in two dimensions, and a more complicated example.

More on Prefix Sums

Computing range sum queries in constant time over a fixed 1D array.

Introduction to Prefix Sums

A data structure that supports insert, query max, and pop max.

Priority Queues

Using a custom comparator to sort custom objects or values in a non-default order, and compressing values from a large range to a smaller one.

Custom Comparators and Coordinate Compression

Iterating two monotonic pointers across an array to search for a pair of indices satisfying some condition in linear time.

Two Pointers

DP on Trees - Solving For All Roots

Combinatorics

Final tips for Gold and additional practice problems.

Additional Practice for USACO Gold

Incorporating custom comparators into standard library containers.

(Optional) Sorted Sets with Custom Comparators

DP problems that require iterating over subsets.

Bitmask DP

Solving a DP problem on every contiguous subarray of the original array.

Range DP

DP on Trees - Introduction

The Disjoint Set Union (DSU) data structure, which allows you to add edges to a graph and test whether two vertices of the graph are connected.

Disjoint Set Union

Finding the number of integers in a range that have a property.

Digit DP

Using the information that one integer evenly divides another.

Divisibility

Quickly testing equality of substrings or sets with a small probability of failure.

Hashing

Maintaining collections of distinct elements with hashing.

(Optional) Hashmaps

Speeding up naive recursive solutions with memoization.

Introduction to DP

Finding the next element smaller or larger than a specified key in a sorted set, and using iterators with sorted sets.

More Operations on Sorted Sets

Problems that can be modeled as filling a limited-size container with items.

Knapsack DP

Finding and using the longest increasing subsequence of an array.

Longest Increasing Subsequence

Finding a subset of the edges of a connected, undirected, edge-weighted graph that connects all the vertices to each other of minimum total weight.

Minimum Spanning Trees

Problems involving dividing the search space into two.

Meet In The Middle

Modular Arithmetic

Segment Tree, Binary Indexed Tree, and Order Statistic Tree (in C++).

Point Update Range Sum

Counting the number of "special" paths on a grid, and how some string problems can be solved using grids.

Paths on Grids

Bellman-Ford, Floyd-Warshall, and Dijkstra.

Shortest Paths with Non-Negative Edge Weights

Maintaining data over consecutive subarrays.

Sliding Window

A data structure that only allows insertion and deletion at one end.

Stacks

Using ternary or binary search to find the mode of unimodal functions.

Optimizing Unimodal Functions

Ordering the vertices of a directed acyclic graph such that each vertex is visited before its children.

Topological Sort

Flattening a tree into an array to easily query and update subtrees.

Euler Tour Technique

Introduces how BFS can be used to find shortest paths in unweighted graphs.

Shortest Paths with Unweighted Edges

Extending Range Queries to 2D (and beyond).

2D Range Queries

Binary Jumping

Examples of how bitsets give some unintended solutions on recent USACO problems.

(Optional) Bitsets

Decomposing a tree to facilitate path computations.

Centroid Decomposition

Final tips for Platinum and additional practice problems.

Additional Practice for USACO Platinum

Smallest convex polygon containing a set of points on a grid.

Convex Hull

A way to find the maximum or minimum value of several convex functions at given points.

Convex Hull Trick

Using Divide & Conquer as a DP Optimization.

Divide & Conquer - DP

Using Divide & Conquer to answer offline or online range queries on a static array.

Divide & Conquer - SRQ

Solving subset sum problems efficiently with DP.

Sum over Subsets DP

Geometry Primitives

Heavy-Light Decomposition

Repeatedly multiplying a square matrix by itself.

Matrix Exponentiation

Small-To-Large Merging

The inclusion-exclusion principle is a counting technique that generalizes the formula for computing the size of union of n finite sets.

Inclusion-Exclusion Principle

Lazy updates on segment trees and two binary indexed trees in conjunction.

Range Update Range Query

/*- [OnlineGDB](https://www.onlinegdb.com/)
- online compiler with embedded GDB debugger
- supports files and file I/O
- can be buggy sometimes*/
"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const frontmatter = undefined;
function _createMdxContent(props) {
  const _components = {
    a: "a",
    h2: "h2",
    li: "li",
    p: "p",
    strong: "strong",
    ul: "ul",
    ...props.components
  }, {HeaderLink, Warning} = _components;
  if (!HeaderLink) _missingMdxReference("HeaderLink", true);
  if (!Warning) _missingMdxReference("Warning", true);
  return _jsxs(_Fragment, {
    children: [_jsxs(_components.h2, {
      id: "running-code-online",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#running-code-online",
        children: _jsx(HeaderLink, {})
      }), "Running Code Online"]
    }), "\n", _jsx(_components.p, {
      children: "In all of C++, Python, Java. All of these options are free."
    }), "\n", "\n", _jsxs(_components.ul, {
      children: ["\n", _jsxs(_components.li, {
        children: [_jsx(_components.a, {
          href: "https://ide.usaco.guide/",
          rel: "nofollow",
          target: "_blank",
          children: "ide.usaco.guide"
        }), "\n", _jsxs(_components.ul, {
          children: ["\n", _jsx(_components.li, {
            children: "Real-time collaboration (share the URL including the hash)"
          }), "\n", _jsx(_components.li, {
            children: "The number of submissions is limited, so please don't excessively spam the\n\"Run\" button..."
          }), "\n", _jsxs(_components.li, {
            children: ["Can be unstable at times; if it starts acting weird, then make a new file. Report issues ", _jsx(_components.a, {
              href: "https://github.com/cpinitiative/ide",
              rel: "nofollow",
              target: "_blank",
              children: "on Github"
            }), "."]
          }), "\n", _jsxs(_components.li, {
            children: ["This is the newer version of ", _jsx(_components.a, {
              href: "https://ide.thecodingwizard.me/",
              rel: "nofollow",
              target: "_blank",
              children: "https://ide.thecodingwizard.me/"
            })]
          }), "\n"]
        }), "\n"]
      }), "\n", _jsxs(_components.li, {
        children: [_jsx(_components.a, {
          href: "https://ide.judge0.com/",
          rel: "nofollow",
          target: "_blank",
          children: "ide.judge0.com"
        }), "\n", _jsxs(_components.ul, {
          children: ["\n", _jsx(_components.li, {
            children: "Basically the above except without real-time collaboration, more stable."
          }), "\n"]
        }), "\n"]
      }), "\n", _jsxs(_components.li, {
        children: [_jsx(_components.a, {
          href: "https://csacademy.com/workspace/",
          rel: "nofollow",
          target: "_blank",
          children: "CSAcademy Workspace"
        }), "\n", _jsxs(_components.ul, {
          children: ["\n", _jsx(_components.li, {
            children: "Pretty nice (unless you get \"Estimated Queue Time: ...\")"
          }), "\n", _jsxs(_components.li, {
            children: ["\"Saved locally\" will ", _jsx(_components.strong, {
              children: "not"
            }), " save your code if you close the tab, press\nCommand-S to save."]
          }), "\n"]
        }), "\n"]
      }), "\n"]
    }), "\n", _jsxs(_components.p, {
      children: ["You can also share code with ", _jsx(_components.a, {
        href: "https://pastebin.com/",
        rel: "nofollow",
        target: "_blank",
        children: "pastebin"
      }), " or\n", _jsx(_components.a, {
        href: "https://hastebin.com/",
        rel: "nofollow",
        target: "_blank",
        children: "hastebin"
      }), "."]
    }), "\n", _jsx(Warning, {
      children: _jsx(_components.p, {
        children: "Your code should not be publicly viewable during a contest. Make sure any online\neditor you use keeps your code private."
      })
    }), "\n", _jsxs(_components.h2, {
      id: "running-code-locally",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#running-code-locally",
        children: _jsx(HeaderLink, {})
      }), "Running Code Locally"]
    }), "\n", _jsxs(_components.p, {
      children: ["See ", _jsx(_components.a, {
        href: "/general/running-code-locally",
        children: "here"
      }), " for more information."]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  frontmatter,
  default: MDXContent
};
function _missingMdxReference(id, component) {
  throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it.");
}


Table of Contents

Table of Contents

Running Code Online

Running Code Locally

Module Progress:

Join the USACO Forum!