添加题解

基础调试

选择编程语言

比赛策略

编程比赛

参与贡献

在命令行中使用 C++

数据类型

如何调试

C++ 调试

前置知识要求

快速输入输出

（选学）C++——编写泛型代码

输入与输出

算法竞赛简介

（可选）C++ Lambda 表达式

资源：学习编程

模块介绍

信息学奥林匹克竞赛

如何练习

资源：算法竞赛

资源：美国相关

在本地运行代码

在线运行代码

USACO 集训营

USACO 常见问题

USACO 月赛题目

如何使用本指南

使用 MDX

非典型问题

分类讨论

使用递归的完全搜索

USACO 铜组补充练习

基础完全搜索

数据结构简介

图简介

贪心算法简介

集合与映射简介

排序简介

矩形几何

模拟

时间复杂度

组合数学

整除

模运算

Binary Search

Binary Search on a Sorted Array

Additional Practice for USACO Silver

Flood Fill

Introduction to Functional Graphs

Graph Traversal

Greedy Algorithms with Sorting

Intro to Bitwise Operators

Introduction to Tree Algorithms

More on Prefix Sums

Introduction to Prefix Sums

Priority Queues

Custom Comparators and Coordinate Compression

Two Pointers

DP on Trees - Solving For All Roots

Additional Practice for USACO Gold

(Optional) Sorted Sets with Custom Comparators

Bitmask DP

Range DP

DP on Trees - Introduction

Disjoint Set Union

Digit DP

Hashing

(Optional) Hashmaps

Introduction to DP

More Operations on Sorted Sets

Knapsack DP

(Optional) LCA with Euler Tour

Longest Increasing Subsequence

Minimum Spanning Trees

(Optional) Meet In The Middle

Point Update Range Sum

Paths on Grids

Shortest Paths with Non-Negative Edge Weights

Sliding Window

Stacks

Optimizing Unimodal Functions

Topological Sort

(Optional) Euler Tour Technique

Shortest Paths with Unweighted Edges

2D Range Queries

Binary Jumping

(Optional) Bitsets

Centroid Decomposition

Additional Practice for USACO Platinum

Convex Hull

Convex Hull Trick

Divide & Conquer - DP

Divide & Conquer - SRQ

Sum over Subsets DP

Geometry Primitives

Heavy-Light Decomposition

Matrix Exponentiation

Small-To-Large Merging

Inclusion-Exclusion Principle

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
const frontmatter = undefined;
function _createMdxContent(props) {
  const _components = {
    a: "a",
    h2: "h2",
    h3: "h3",
    li: "li",
    p: "p",
    ul: "ul",
    ...props.components
  }, {HeaderLink} = _components;
  if (!HeaderLink) _missingMdxReference("HeaderLink", true);
  return _jsxs(_Fragment, {
    children: [_jsxs(_components.p, {
      children: ["最理想的比赛策略当然是赛前什么都会。不过能做到的人屈指可数，比如\n", _jsx(_components.a, {
        href: "https://codeforces.com/profile/benq",
        rel: "nofollow",
        target: "_blank",
        children: "Benq"
      }), " 或\n", _jsx(_components.a, {
        href: "https://codeforces.com/profile/tmwilliamlin168",
        rel: "nofollow",
        target: "_blank",
        children: "tmw"
      }), "（开个玩笑）。"]
    }), "\n", _jsx(_components.p, {
      children: "计时开始后已经没有时间继续学习；合理分配时间，是最大化得分的最好办法。"
    }), "\n", _jsxs(_components.h2, {
      id: "总体策略",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#总体策略",
        children: _jsx(HeaderLink, {})
      }), "总体策略"]
    }), "\n", _jsx(_components.p, {
      children: "策略没有固定答案，所有建议都应结合实际情况判断。最合适的策略应当针对\n_你自己_量身制定。"
    }), "\n", _jsxs(_components.h3, {
      id: "比赛开始时",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#比赛开始时",
        children: _jsx(HeaderLink, {})
      }), "比赛开始时"]
    }), "\n", _jsx(_components.p, {
      children: "首先应该阅读_所有_题目，不要过早放弃任何一题。通常，在开始写代码之前应当\n进行充分思考。根据比赛难度，你可能需要先用纸笔思考 5 分钟到 2 小时，之后\n才开始敲键盘。"
    }), "\n", _jsx(_components.p, {
      children: "题目未必按难度排序，因此不要在第一题上卡三个小时却毫无进展。应先认真思考\n每一道题，再决定重点攻克哪些、暂时搁置哪些。"
    }), "\n", _jsxs(_components.h3, {
      id: "时间分配",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#时间分配",
        children: _jsx(HeaderLink, {})
      }), "时间分配"]
    }), "\n", _jsx(_components.p, {
      children: "在一道题上投入数小时后才发现另一题其实很容易，是非常糟糕的体验。合理分配\n时间可以避免这种情况。你需要自行判断哪些题有希望解决，以及何时应该止损。\n一般不要在单题上花费“过长”时间，也应谨慎对待明显考查自己不熟悉知识的题目。"
    }), "\n", _jsxs(_components.h3, {
      id: "想到解法时",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#想到解法时",
        children: _jsx(HeaderLink, {})
      }), "想到解法时"]
    }), "\n", _jsx(_components.p, {
      children: "如果读题时立刻想到了完整解法，可以尽快写完代码，先拿下这道题。"
    }), "\n", _jsx(_components.p, {
      children: "另一种选择是先思考其他题，再回来实现已经会做的题。回来时可以重新确认解法\n是否仍然严密，同时让其他题的思路在写代码期间继续酝酿。"
    }), "\n", _jsxs(_components.h3, {
      id: "存在部分分时",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#存在部分分时",
        children: _jsx(HeaderLink, {})
      }), "存在部分分时"]
    }), "\n", _jsx(_components.p, {
      children: "如果题目可以通过部分解法获得分数（USACO 就是如此），应始终留意各个子任务。\n争取部分分主要有两种方式："
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsxs(_components.li, {
        children: ["把大部分时间用于思考完整解法；若临近结束仍未解决，再实现部分分。\n", _jsxs(_components.ul, {
          children: ["\n", _jsx(_components.li, {
            children: "想到完整解法后务必确认正确性，避免花一小时实现一个完全错误的方案。"
          }), "\n", _jsx(_components.li, {
            children: "仔细估计子任务难度：实现可能只需 30 秒，也可能需要 30 分钟；看似简单的\n子任务未必真的简单。"
          }), "\n"]
        }), "\n"]
      }), "\n", _jsx(_components.li, {
        children: "从部分分逐步向上：先实现最简单的子任务，再挑战更难的。子任务可能帮助你\n发现完整解法，也能让解题过程保持清晰。"
      }), "\n"]
    }), "\n", _jsxs(_components.h2, {
      id: "个人经验",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#个人经验",
        children: _jsx(HeaderLink, {})
      }), "个人经验"]
    }), "\n", _jsxs(_components.h3, {
      id: "nathan-chen",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#nathan-chen",
        children: _jsx(HeaderLink, {})
      }), "Nathan Chen"]
    }), "\n", _jsx(_components.p, {
      children: "在铂金组，我会先读完所有题，然后通常用第一个小时思考最容易的两题（最难题\n往往真的非常难）。之后继续思考，一旦认为解法成立就开始实现。我习惯把部分分\n留到最后：只有时间快用完却仍没有完整解法时才去写。"
    }), "\n", _jsxs(_components.h3, {
      id: "benjamin-qi",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        className: "anchor before",
        href: "#benjamin-qi",
        children: _jsx(HeaderLink, {})
      }), "Benjamin Qi"]
    }), "\n", _jsx(_components.p, {
      children: "先拿到力所能及的部分分；希望写完这些时，你已经想出了完整解法。:D"
    })]
  });
}
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.");
}


在 USACO 比赛中制定策略的一般思路。

Table of Contents

Table of Contents

总体策略

比赛开始时

时间分配

想到解法时

存在部分分时

个人经验

Nathan Chen

Benjamin Qi

Module Progress: