Author: Nathan Gong
Throughout my personal experience of reaching the Platinum division and coaching dozens of students, I’ve come across a few mistakes that competitors (myself included) have been consistently making.
Here’s the full video discussing the same content in detail:
Mistake #1: Only practicing with topic lists
Popular sites like USACO Guide and Codeforces compile problems into different concepts. For example, on the USACO Guide, problems are divided into sections like depth-first search, prefix sums, and binary search.
The problem with practicing using these divided sections is that you already know what algorithm or data structure you're supposed to use before you even start solving a problem. This takes away a huge part of the problem-solving process, which is identifying the best algorithm to use in each situation. In a real contest, you won't be given this information, so it's crucial to practice under the same conditions. A great way to do this is to go through all the problems in the past contests section on the official USACO website.
It's important to note that this doesn't mean you shouldn't use the USACO Guide or topic lists. The organization it provides is amazing for when you're starting out and trying to learn all the concepts tested in each division. However, once you feel comfortable with every concept, we recommend shifting your practice more to going through past contests.
Mistake #2: Emphasizing learning algorithms and data structures over getting better at problem-solving
In earlier divisions, having strong problem-solving skills is far more important than knowing a lot of algorithms and data structures. Generally, the only knowledge needed for Bronze is sorting, sets, and maps. And even then, you almost never need to actually implement any of these algorithms. As such, focusing your time on learning new algorithms will provide far less value than working on your problem solving abilities. You’re not going to pass a contest because you know how merge sort works. You’re passing it because you’ve built a deep understanding of how to apply sorting in a bunch of different situations. All of this applies to Silver as well, just make sure that you have concepts like binary search, graphs, depth-first search, and prefix sums down.
Mistake #3: Giving up Too Early
One common mistake that many people make during practice is that they’ll give up after just a few minutes of thinking in their head and not finding a solution. It’s crucial to spend at least 15-20 minutes thinking hard about the problem. Grab a piece of paper and sketch out examples or potential solution ideas to get better insights.
Only when you genuinely find yourself stuck and unable to progress after these 15-20 minutes should you resort to reading the editorial. Once you’ve understood the solution, it’s important that you implement the solution yourself without referring to the editorial code. Although it may seem like a waste of time, implementing the solution is key to make sure that you thoroughly understand how the problem works, and gives you further practice with something that you weren’t previously familiar with.
After you’re all done, take some time to reflect. If you weren’t able to solve the problem the first time around, think about what observations you missed out on that prevented you from getting to the solution. Also consider how you could’ve approached the problem differently such that you’d be able to make those observations the next time around.
Alternatively, if you managed to solve the problem, but it took a considerable amount of time, analyze where you spent the most time and think about how you could’ve been more efficient. This might involve writing more concise code, testing ideas before full implementation, or breaking down your solution into smaller parts.
Mistake #4: Poor Contest Strategy
During contests, a lot of competitors will start by reading through the first problem and jumping straight into implementation. This is almost always the incorrect approach. Contest problems are not ordered by difficulty, so you may very well be starting with the hardest question. Instead, you should read all problems before starting and tackle the easiest one first.
When you’ve identified a solution for the problem you’re working on, make sure that it works before you start implementing. This means spending a few minutes coming up with test cases of your own (beyond the samples) and proving to yourself that the solution works. You don’t want to be an hour into implementation just to realize that your solution is completely wrong!
For more about contest strategy, I strongly recommend watching Riya’s video. The main idea of her video is to keep a contest log noting down what you’ve been working on every 15 minutes. Not only will it help you realize when you’ve spent too much time on one problem, but it will also help you analyze your time allocation and identify where you were inefficient after the contest is over.
Mistake #5: Debugging With Print Statements
This mistake is slightly controversial, but changing the way I debug has personally enabled me to find mistakes in my code much faster. While print statements are great for debugging smaller programs where there isn’t too much going on, they can often get overwhelming for more complex problems. For these cases, I strongly recommend learning to use the debug function in your IDE. Here’s a tutorial showing how to use a debugger: https://www.youtube.com/watch?v=x0yLsPX6tTY.
I hope you found at least one of these points helpful! By avoiding these mistakes, you should find your practice to be more efficient and your progress to be much faster. For me personally, recognizing and avoiding these mistakes have saved me a lot of time, helping me jump to Platinum within two contests after being stuck in Silver for an entire year.