Kontes CP bukan hanya tes algoritma — kontes adalah tes manajemen waktu dan pengambilan keputusan di bawah tekanan. Kontestan yang menyelesaikan 5 soal dalam 2 jam dengan urutan yang tepat mengalahkan kontestan yang menyelesaikan 5 soal dengan urutan acak — perbedaan rating bisa ratusan poin. Pada Chapter ini kita akan membangun simulasi kontes dengan strategi “pick easy, skip, revisit”, mendefinisikan aturan skip berdasarkan waktu stagnasi, dan checklist verifikasi sebelum submit. Tujuan akhirnya: ketika kontes dimulai, kita punya kerangka keputusan yang jelas, bukan reaksi panik.

Lima Fase Kontes Standar (2 Jam) #

FaseDurasiTindakan
1. Baca semua0–10 menitSkim seluruh soal, identifikasi mudah
2. Solve mudah10–60 menitKerjakan soal termudah dulu
3. Tengah kontes60–90 menitLanjut ke soal menengah, skip bila stuck
4. Akhir kontes90–110 menitFokus pada satu soal tersulit yang paling mungkin
5. Buffer110–120 menitReview, periksa edge case, jangan submit panic

Mekanisme: Mengurutkan Soal Berdasarkan Difficulty #

Soal CP biasanya diurutkan berdasarkan difficulty — A paling mudah, E paling sulit. Tetapi urutan ini tidak selalu akurat 100%. Strategi “pick easy” mengharuskan kita:

  1. Skim seluruh soal dalam 10 menit pertama.
  2. Estimasi difficulty relatif: “soal A tampak lebih mudah dari B, tetapi C lebih cepat dari A karena implementasi sederhana.”
  3. Buat urutan kerja sendiri berdasarkan estimasi.
  4. Kerjakan dari yang termudah, jangan stuck pada satu soal.

Kode: Simulasi Strategi Kontes #

cpp 
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

struct Problem {
    std::string code;
    int difficulty;
    int minutes_solve;
    bool solved;
};

int main() {
    std::vector<Problem> contest = {
        {"A", 800,  10, false},
        {"B", 1200, 25, false},
        {"C", 1600, 45, false},
        {"D", 2000, 60, false},
        {"E", 2400, 90, false},
    };

    // Strategi: sort by difficulty, kerjakan dari termudah.
    std::sort(contest.begin(), contest.end(),
              [](const Problem& a, const Problem& b) { return a.difficulty < b.difficulty; });

    int total_time = 120;
    int elapsed = 0;
    int solved_count = 0;

    std::cout << "=== Simulasi Strategi Kontes (120 menit) ===\n\n";
    std::cout << "Aturan: kerjakan soal termudah dulu, skip bila stuck > 15 menit.\n\n";

    for (auto& p : contest) {
        if (elapsed + p.minutes_solve > total_time) {
            std::cout << "[SKIP] " << p.code << " (difficulty " << p.difficulty
                      << ") — tidak cukup waktu tersisa ("
                      << (total_time - elapsed) << " min < "
                      << p.minutes_solve << " min)\n";
            continue;
        }
        bool ok = (p.minutes_solve <= 60);
        std::cout << "[ATTEMPT] " << p.code << " (difficulty " << p.difficulty
                  << ", est. " << p.minutes_solve << " min)\n";
        elapsed += p.minutes_solve;
        if (ok) {
            p.solved = true;
            solved_count++;
            std::cout << "  -> SOLVED at t=" << elapsed << " min\n";
        } else {
            std::cout << "  -> SKIP after stuck (move to next)\n";
        }
    }

    std::cout << "\n=== Hasil Kontes ===\n";
    std::cout << "Solved: " << solved_count << " dari " << contest.size() << " soal\n";
    std::cout << "Waktu terpakai: " << elapsed << " menit dari " << total_time << "\n\n";

    std::cout << "=== Strategi Manajemen Waktu ===\n";
    std::cout << "Fase               | Durasi     | Tindakan\n";
    std::cout << "-------------------|------------|-----------------------------------------\n";
    std::cout << "1. Baca semua      | 0-10 min   | Skim seluruh soal, identifikasi mudah\n";
    std::cout << "2. Solve mudah     | 10-60 min  | Kerjakan soal termudah dulu\n";
    std::cout << "3. Tengah kontes   | 60-90 min  | Soal menengah, skip bila stuck\n";
    std::cout << "4. Akhir kontes    | 90-110 min | Fokus pada satu soal tersulit yang paling mungkin\n";
    std::cout << "5. Buffer          | 110-120 min| Review, periksa edge case\n\n";

    std::cout << "=== Aturan Skip ===\n";
    std::cout << "- Stuck > 15 menit pada satu soal -> SKIP\n";
    std::cout << "- Setelah semua soal dicoba, baru kembali ke yang di-skip\n";
    std::cout << "- Jangan habiskan > 30 menit pada satu soal tanpa progress\n\n";

    std::cout << "=== Tips Verifikasi Sebelum Submit ===\n";
    std::cout << "1. Compile tanpa warning (-Wall -Wextra)\n";
    std::cout << "2. Test sample input — output harus persis sama\n";
    std::cout << "3. Test edge case: n=1, n=0, nilai max, semua sama\n";
    std::cout << "4. Periksa tipe data: int vs long long untuk akumulasi\n";
    std::cout << "5. Periksa format output: newline, separator, presisi\n";
    std::cout << "6. Hitung kompleksitas vs constraint -> pastikan tidak TLE\n";
    return 0;
}

Output yang Dihasilkan:

text 
=== Simulasi Strategi Kontes (120 menit) ===

Aturan: kerjakan soal termudah dulu, skip bila stuck > 15 menit.

[ATTEMPT] A (difficulty 800, est. 10 min)
  -> SOLVED at t=10 min
[ATTEMPT] B (difficulty 1200, est. 25 min)
  -> SOLVED at t=35 min
[ATTEMPT] C (difficulty 1600, est. 45 min)
  -> SOLVED at t=80 min
[SKIP] D (difficulty 2000) — tidak cukup waktu tersisa (40 min < 60 min)
[SKIP] E (difficulty 2400) — tidak cukup waktu tersisa (40 min < 90 min)

=== Hasil Kontes ===
Solved: 3 dari 5 soal
Waktu terpakai: 80 menit dari 120

=== Strategi Manajemen Waktu ===
Fase               | Durasi     | Tindakan
-------------------|------------|-----------------------------------------
1. Baca semua      | 0-10 min   | Skim seluruh soal, identifikasi mudah
2. Solve mudah     | 10-60 min  | Kerjakan soal termudah dulu
3. Tengah kontes   | 60-90 min  | Soal menengah, skip bila stuck
4. Akhir kontes    | 90-110 min | Fokus pada satu soal tersulit yang paling mungkin
5. Buffer          | 110-120 min| Review, periksa edge case

=== Aturan Skip ===
- Stuck > 15 menit pada satu soal -> SKIP
- Setelah semua soal dicoba, baru kembali ke yang di-skip
- Jangan habiskan > 30 menit pada satu soal tanpa progress

=== Tips Verifikasi Sebelum Submit ===
1. Compile tanpa warning (-Wall -Wextra)
2. Test sample input — output harus persis sama
3. Test edge case: n=1, n=0, nilai max, semua sama
4. Periksa tipe data: int vs long long untuk akumulasi
5. Periksa format output: newline, separator, presisi
6. Hitung kompleksitas vs constraint -> pastikan tidak TLE

Bedah Kode Baris-per-Baris #

  1. std::sort(contest.begin(), contest.end(), [](const Problem& a, const Problem& b) { ... }): sort soal berdasarkan difficulty. Ini mensimulasikan keputusan kontestan setelah membaca semua soal — kerjakan dari yang termudah.
  2. if (elapsed + p.minutes_solve > total_time): cek apakah masih ada waktu cukup. Bila tidak, skip soal. Pada simulasi, D dan E di-skip karena waktu tersisa (40 menit) kurang dari estimasi (60 dan 90 menit).
  3. bool ok = (p.minutes_solve <= 60);: simulasi keberhasilan. Soal dengan estimasi ≤ 60 menit berhasil; lebih dari itu dianggap stuck.
  4. elapsed += p.minutes_solve;: akumulasi waktu. Pada kontes nyata, ini diukur secara real-time — penting untuk tracking progress.
  5. solved_count: jumlah soal yang berhasil. Tujuan akhir kontes adalah maksimalkan ini dengan urutan optimal.

Aturan Skip: Kapan Pindah dari Soal #

Aturan praktis tiga ambang batas:

SituasiTindakan
Stuck 5 menit pertamaTetap berpikir — terlalu dini untuk skip
Stuck 15 menit tanpa ide baruSKIP — lanjut ke soal berikutnya
Stuck 30 menit tanpa progressSkip permanen — revisi di akhir kontes saja
60 menit terakhirFokus pada satu soal yang paling mungkin selesai

Strategi Submission: Sekali vs Bertahap #

PendekatanKeuntunganRisiko
Submit segera setelah sample OKHemat waktuBisa WA pada hidden test
Submit setelah verifikasi ekstraLebih yakin ACWaktu habis untuk verifikasi

Rekomendasi:

  1. Setelah kode selesai, jalankan sample — bila salah, fix.
  2. Jalankan edge case minimal (n=1, n=0, max value).
  3. Submit.
  4. Bila WA, baca verdict dengan teliti (test ke berapa yang gagal?), analisis pola, fix.

Verifikasi Sebelum Submit: Checklist #

ItemVerifikasi
1. Compile bersihg++ -std=c++17 -O2 -Wall -Wextra tanpa warning
2. Sample inputOutput persis sama dengan sample output
3. Edge casen=1, n=0, nilai max/min, semua sama
4. Tipe dataAkumulator sum long long bila perlu
5. Format outputNewline di akhir, separator, presisi float
6. Kompleksitasn × ops ≤ 10^8 untuk time limit 1 detik
7. MemoriStruktur data ≤ 256 MB
8. BoundaryArray [n] bukan [n-1], indeks 0 vs 1

Ringkasan #

  • Lima fase kontes: baca semua (10 mnt) → solve mudah (50 mnt) → tengah (30 mnt) → akhir (20 mnt) → buffer (10 mnt).
  • Strategi “pick easy” — kerjakan soal termudah dulu, sort by difficulty setelah membaca semua.
  • Aturan skip: 15 menit stuck → pindah; 30 menit → skip permanen; 60 menit terakhir → fokus satu soal.
  • Sebelum submit: jalankan sample, test edge case, cek tipe data, hitung kompleksitas.
  • Hindari panic submit di menit akhir — kode tidak teruji lebih berbahaya daripada tidak submit.