********************************************
International Collegiate Programming Contest
********************************************

Introduction
============
The International Collegiate Programming Contest (ICPC) is a multi-tier,
team-based, programming competition. It is one of the oldest and most
prestigious programming contests in the world. The contest is open to
university students from around the world. The contest is a great opportunity
for students to showcase their programming skills and compete against other
students from around the world.

Levels of Competition
---------------------
+ Local Contests
+ Regional Contests
+ Reginal Championships
+ World Finals

Contest Format
--------------
+ Teams of three students
+ Five-hour contest
+ 8-12 problems
+ In C, C++, Java, Python 3, or Kotlin

ICPC at UWF
===========
+ Hosted by the CS department and assisted by the ACM student chapter
+ Participated in the Southeast USA Regional Contest
+ UWF Teams have performed well in D2 in the past

Important Dates
---------------
+ Registration: 9/19-11/3, 2025
+ Contest: Nov. 8, 2025

ICPC Resources
==============
+ `ICPC Official Website <https://icpc.global/>`_
+ `Kattis <https://open.kattis.com/>`_ for official practice problems
+ `Past Southeast USA Regional Contest <http://seusa.vanb.org/>`_

ICPC Preparation Resources
==========================
+ GitHub Repositories

  * https://github.com/BedirT/ACM-ICPC-Preparation
  * https://github.com/buckeye-cn/ACM_ICPC_Materials

+ Online Judge Platforms

  * LeetCode: problems, discussions, and learning resources
  * CodeChef: problems, and learning resources
  * CodeForces
  * TopCoder

+ Textbooks for References

  * Introduction to Algorithms by Thomas H. Cormen, etc.
  * Algorithms by Robert Sedgewick, etc.
  * Competitive Programming 3 by Steven Halim


ICPC Strategy
=============

1. Contest Workflow and Strategy

  The overarching goal is to **maximize the number of problems solved** while
  **minimizing time penalties**.

  + **Problem Reading (The Start):**

    * The team should **skim the entire problem set in parallel** (e.g., one
      person reads from the front, one from the back) to quickly identify the
      **easiest problems** (the "low-hanging fruit").
    * The quickest typist should simultaneously set up the **code template**
      and compilation script on the computer.

  + **Prioritization:** Solve the easy problems first. Look at the
    **scoreboard** periodically—if many other teams have solved a problem, it's
    likely easy and should be a high priority.
  + **Discussion and Verification:** If a solution is unclear or stuck,
    **discuss it with a teammate**. Explaining the problem aloud can often
    reveal the flaw in the logic.
  + **The Tester Role:** A dedicated team member should be ready to **generate
    tricky and edge test cases** (e.g., maximum constraints, zero/one inputs)
    while the coder is implementing the solution.
  + **Endgame Strategy:** As time runs out (e.g., the last hour), shift from
    working on separate problems to **focusing all effort on one or two
    high-priority problems**. This may involve one person coding while others
    proofread the code and generate final test cases.

2. Coding and Debugging Practices

  Efficiency at the keyboard and avoiding costly mistakes are paramount.

  + **Write on Paper First:** For complex algorithms, **write out the core
    logic or pseudocode on paper** before going to the computer. This saves
    precious computer time and helps prevent off-by-one or boundary errors.
  + **Use a Code Library/Template:** Have a **well-tested personal library** of
    common algorithms (e.g., graph algorithms, data structures, geometric
    primitives) and a **boilerplate code template** ready to use.
  + **Debugging on Paper:** **Avoid debugging on the computer terminal** with
    print statements. If a bug is elusive, **print out the code and the
    debugging output** and find the error by manually tracing the execution on
    paper.
  + **Automated Testing:** **Use a script** to automatically run your code
    against all local test cases (sample and custom-made) to ensure consistency
    and speed.
  + **Language Choice:** Stick with the language you are **most confident** in
    (usually C++ or Java). All team members should use similar coding
    conventions to make reading and debugging each other's code easier.

3. Preparation and Team Dynamics

  Success in ICPC is built long before the contest starts.

  + **Practice Together:** **Train often** as a team to understand each other's
    strengths and weaknesses and to refine your collective strategy and
    time-sharing at the single computer.
  + **Upsolving:** After every practice contest, **upsolve** (solve the
    problems you missed). This is the best way to learn new techniques and
    solidify algorithmic knowledge.
  + **Study Algorithms:** Systematically study core and advanced algorithms,
    focusing on **data structures** (Segment Trees, Tries, Fenwick Trees),
    **graph algorithms** (Dijkstra's, MST, Max Flow), **dynamic programming**,
    and **number theory**.
  + **Health and Focus:** Ensure you are **well-rested and hydrated** during
    the contest. Taking a quick walk or a short break can often help clear the
    mind when stuck on a tough problem.

Past Contests
=============
.. toctree::
  :maxdepth: 1

  seusa2025