Merge branch 'master' of https://github.com/thecodingwizard/usaco-guide

15 files changed, 70 insertions, 65 deletions

diff --git a/content/1_Intro/Choosing_Lang.mdx b/content/1_Intro/Choosing_Lang.mdx
index dde8044..8014ff4 100644
--- a/content/1_Intro/Choosing_Lang.mdx
+++ b/content/1_Intro/Choosing_Lang.mdx
@@ -39,6 +39,8 @@ If you aren't comfortable with basic coding yet, you can use the resources below
 
 <CPPSection>
 
+### C++
+
 Use one of the resources above or below (or find your own) to learn C++. If you use Sololearn, you don't have to complete the full course; we recommend you finish everything up to (but not including) "More on Classes."
 
 <Resources title="C++">
diff --git a/content/1_Intro/Data_Types.mdx b/content/1_Intro/Data_Types.mdx
index 7e092b8..54e4a78 100644
--- a/content/1_Intro/Data_Types.mdx
+++ b/content/1_Intro/Data_Types.mdx
@@ -19,8 +19,7 @@ prerequisites:
 
 There are several main **data types** that are used in contests: integers, floating point numbers, booleans, characters, and strings. Assuming that you are familiar with the language you are using, this should be mostly review.
 
-The normal **32-bit integer** data type (`int` in C++ and Java) supports values between $−2\,147\,483\,648 and 2\,147\,483\,647, which is
-roughly equal to $\pm 2 \cdot 10^9$.
+The normal **32-bit integer** data type (`int` in C++ and Java) supports values between $−2\,147\,483\,648$ and $2\,147\,483\,647$, which is roughly equal to $\pm 2 \cdot 10^9$.
 
 Some problems require you to use **64-bit integers** (`long long` in C++ and `long` in Java) instead of 32-bit integers (`int`). 64-bit integers are less likely to have overflow issues, since they can store any number between $-9\,223\,372\,036\,854\,775\,808$ and $9\,223\,372\,036\,854\,775\,807$ which is roughly equal to $\pm 9 \times 10^{18}$.
 
@@ -30,16 +29,14 @@ Sometimes (but not always) a USACO problem statement (ex. [Haircut](http://www.u
 
 Contest problems are usually set such that the 64-bit integer is sufficient, so it might be a good idea to use 64-bit integers in place of 32-bit integers everywhere. Of course, you shouldn't do this when time and/or memory limits are tight, which may be the case in higher divisions of USACO. Also note that in Java, you will need to cast `long` back to `int` when accessing array indices. 
 
-**Floating point numbers** are used to store decimal values. It is important to know that floating point numbers are not exact, because the binary architecture of computers can only store decimals to a certain precision. Hence, we should always expect that floating point numbers are slightly off. It's generally a bad idea to compare two floating-point numbers for exact equality (`==`); instead, check if their absolute difference is less than some small constant like $10^{-9}$. 
+**Floating point numbers** are used to store decimal values. It is important to know that floating point numbers are not exact, because the binary architecture of computers can only store decimals to a certain precision. Hence, we should always expect that floating point numbers are slightly off, so it's generally a bad idea to compare two floating-point numbers for exact equality (`==`).
 
-Contest problems will accommodate the inaccuracy of floating point numbers in two different ways. 
+Contest problems will usually accommodate the inaccuracy of floating point numbers by checking if the **absolute** or **relative** difference between your output and the answer is less than some small constant like $\epsilon=10^{-9}$. 
 
-USACO problems generally have a unique answer, so when floating point is necessary, the output format will be something along the lines of "Print $10^6$ times the maximum probability of receiving exactly one accepted invitation, rounded down to the nearest integer." See [USACO Cow Dating](http://www.usaco.org/index.php?page=viewproblem2&cpid=924).
+- If your output is $x$ and the answer is $y$, the absolute difference is $|x-y|$.
+- If your output is $x$ and the answer is $y$, the relative difference is $\frac{|x-y|}{|y|}$.
 
-In CodeForces or other contests, your output will be marked as correct if its absolute or relative difference from the actual answer is less than a given $\epsilon$. 
-
-- If your output is x and the answer is y, the absolute difference is $|x-y|$.
-- If your output is x and the answer is y, the relative difference is $\frac{|x-y|}{y}$.
+This is not the case for USACO, where problems generally have a unique correct output. So when floating point is necessary, the output format will be something along the lines of "Print $10^6$ times the maximum probability of receiving exactly one accepted invitation, rounded down to the nearest integer." (ex. [Cow Dating](http://www.usaco.org/index.php?page=viewproblem2&cpid=924)).
 
 **Boolean** variables have two possible states: `true` and `false`. We'll usually use booleans to mark whether a certain process is done, and arrays of booleans to mark which components of an algorithm have finished.
 
diff --git a/content/1_Intro/Expected.mdx b/content/1_Intro/Expected.mdx
index 8f9e00a..28c77b3 100644
--- a/content/1_Intro/Expected.mdx
+++ b/content/1_Intro/Expected.mdx
@@ -53,7 +53,7 @@ The following require relatively little programming experience and no algorithmi
 
 <Problems problems={problems.general} />
 
-Also check the [CSES Introductory Problems](https://cses.fi/problemset/list/) up to and including "Palindrome Reorder." Once you're done with these, you should continue onto Bronze. 
+Also check the [CSES Introductory Problems](https://cses.fi/problemset/list/) up to and including "Palindrome Reorder." Once you're done with these, you should continue onto the rest of Bronze. 
 
 <Warning>
 
diff --git a/content/1_Intro/Fast_IO.mdx b/content/1_Intro/Fast_IO.mdx
index f16189e..3b5f351 100644
--- a/content/1_Intro/Fast_IO.mdx
+++ b/content/1_Intro/Fast_IO.mdx
@@ -9,7 +9,7 @@ Generally, input and output speed isn't an issue. However, some platinum tasks h
 
 ## Fast Input
 
-The largest USACO input file I know of is test case 11 of [USACO Platinum - Robotic Cow Herd](http://www.usaco.org/index.php?page=viewproblem2&cpid=674), which is 10.3 megabytes! The answer to this test case is $10^{18}$ (with $N=K=10^5$ and all microcontrollers costing $10^8$).
+The largest USACO input file we know of is test case 11 of [USACO Platinum - Robotic Cow Herd](http://www.usaco.org/index.php?page=viewproblem2&cpid=674) (10.3 megabytes). The answer to this test case is $10^{18}$ (with $N=K=10^5$ and all microcontrollers costing $10^8$).
 
 <LanguageSection>
 
diff --git a/content/1_Intro/Intro.mdx b/content/1_Intro/Intro.mdx
index 173e8a1..4c7e9b5 100644
--- a/content/1_Intro/Intro.mdx
+++ b/content/1_Intro/Intro.mdx
@@ -5,6 +5,8 @@ author: Nathan Wang, Benjamin Qi, Darren Yao
 description: What is competitive programming? Let's take a look!
 ---
 
+## Programming Competitions
+
 A [programming competition](https://en.wikipedia.org/wiki/Competitive_programming) generally lasts for several hours and consists of a set of problems. These problems are not open problems; they have already been solved by the problem writers and testers and are designed to be solved in the short timeframe of a contest. In general, each problem in competitive programming is solved with a two-step process: 
 
  1. coming up with the algorithm, which involves problem solving skills and intuition
@@ -30,10 +32,10 @@ For those of you with experience in software development, note that competitive
 
 <!-- </Optional> -->
 
-## USACO Contest Format
+## USACO
 
 <Resources>
-	<Resource source="USACO" title="Contests" url="http://www.usaco.org/index.php?page=contests" starred> </Resource>
+	<Resource source="USACO" title="Contests" url="http://www.usaco.org/index.php?page=contests" starred>more abount contest format</Resource>
 </Resources>
 
 The **USA Computing Olympiad** is a national programming competition that occurs four times a year, with December, January, February, and US Open (March) contests. The regular contests are four hours long, and the US Open is five hours long. Each contest contains three problems. Solutions are evaluated and scored against a set of predetermined test cases that are not visible to the student. Scoring is out of 1000 points, with each problem being weighted equally (\~333 points). There are four divisions of contests: Bronze, Silver, Gold, and Platinum. After each contest, students who meet the contest-dependent cutoff for promotion will compete in the next division for future contests.
diff --git a/content/1_Intro/Practicing.mdx b/content/1_Intro/Practicing.mdx
index 806c39c..38c0190 100644
--- a/content/1_Intro/Practicing.mdx
+++ b/content/1_Intro/Practicing.mdx
@@ -29,10 +29,7 @@ My personal opinion is that it is okay to give up early when solving CP problems
 Sometimes I spend as little as 15-20 minutes on a problem before reading the editorial
 or at least glancing at solution code. Other times I may spend significantly longer.
 
-CP editorials generally aren't the best (with the exception of USACO editorials,
-which are pretty good) so I often spend a lot of time trying to understand the
-solution even after "giving up" and reading the editorial. I think it's good
-enough to implement the code without having the editorial open.
+CP editorials generally aren't the best (with the exception of USACO editorials, which are pretty good) so I often spend a lot of time trying to understand the solution even after "giving up" and reading the editorial. I think it's good enough to implement the code without having the editorial open.
 
 My justification for why I think it's okay to give up so early is as follows:
 
@@ -47,8 +44,7 @@ My justification for why I think it's okay to give up so early is as follows:
   you read the editorial so now you do, then you've learned a lot more.
   - In other words, reading editorials is a _good_ thing, not a bad thing!
 
-Overall, I would just say to "give up" when you feel like giving up, whether that's
-in five hours or in 15 minutes :)
+Overall, I would just say to "give up" when you feel like giving up, whether that's in five hours or in 15 minutes :)
 
 ## Siyong Huang
 
@@ -88,14 +84,18 @@ Read the editorial when you feel like you've stopped making progress; that could
 
 I follow three guidelines (from most important to least important)
 
-1. Having fun, just doing whatever you feel like doing
-2. Spend about the same amount of time that you would be able to during a real contest
-3. Whether you are making progress or not
+1. Having fun, just doing whatever you feel like doing.
+2. Spend about the same amount of time that you would be able to during a real contest.
+3. Whether you are making progress or not.
 
 ## Eric Wei
 
 I think the most important thing regarding practicing is to try to get something out of every problem, whether it's a new algorithm or idea, an implementation trick that can help in the future, or just a bug you hopefully won't mess up in the future. That being said, editorials are more useful once you've been stuck for a while; I think the exploration that happens from being a little stuck is often instructive (and good practice for contests, when it's your only option). But at some point the problem's more frustrating than helpful, and sometime before this is probably the right time to take a hint or read the editorial.
 
+## Michael Cao
+
+Do hard problems, and try to learn something from them. If you read the editorial, think about how you would arrive at the solution if you were to solve it again. Also, it's important to implement every problem you read the editorial of. Most importantly, don't burn yourself out, or you'll just be worse off in the end because your practice isn't efficent.
+
 ## Additional
 
 <Resources>
diff --git a/content/1_Intro/Resources.mdx b/content/1_Intro/Resources.mdx
index 351842b..06216b5 100644
--- a/content/1_Intro/Resources.mdx
+++ b/content/1_Intro/Resources.mdx
@@ -18,22 +18,23 @@ description: A bunch of helpful links.
       - *Will be mentioned extensively in later modules.*
     - [Guide to Competitive Programming](https://www.amazon.com/Guide-Competitive-Programming-Algorithms-Undergraduate/dp/3319725467) is a paid book based off CPH
       - Can currently download PDF for [free](https://link.springer.com/book/10.1007/978-3-319-72547-5)!
+  - [Principles of Algorithmic Problem Solving](http://www.csc.kth.se/~jsannemo/slask/main.pdf) - Johan Sannemo
+    - practice problems from Kattis
   - Intro to USACO - Darren Yao 
     - *Some modules are based off chapters from this book.*
     - covers most of Bronze, Silver
     - [Java](http://darrenyao.com/usacobook/java.pdf), [C++](http://darrenyao.com/usacobook/cpp.pdf) versions
   - Competitive Programming Book - Steven Halim, Felix Halim
-    - [Competitive Programming Book 2](https://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp2.pdf) is freely available but old
+    - [Competitive Programming 2](https://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp2.pdf) is freely available but old
     - [Competitive Programming 4](https://cpbook.net/) is the latest edition of the book (with significant additions) but costs money.
   - [CS Guide](https://github.com/alwayswimmin/cs_guide) - Samuel Hsiang, Alexander Wei, Yang Liu
-    - some more from TJHSST:
-      - [TJ Senior Computer Team](https://activities.tjhsst.edu/sct/)
-      - [TJIOI](https://github.com/tjsct/tjioi-study-guide) (just basics)
-  - [Principles of Algorithmic Problem Solving](http://www.csc.kth.se/~jsannemo/slask/main.pdf) - Johan Sannemo
-    - practice problems from Kattis
+    - The [TJ Senior Computer Team](https://activities.tjhsst.edu/sct/) website might also be of interest.
   - [Cracking the Coding Interview](http://www.crackingthecodinginterview.com/)
     - good book specifically for programming interviews
 
+      <!-- - some more from TJHSST: -->
+      <!-- - [TJIOI](https://github.com/tjsct/tjioi-study-guide) (just basics) -->
+
 ## Courses
 
   - [Competitive Programming Course](https://github.com/SuprDewd/T-414-AFLV) - Bjarki Ágúst Guðmundsson
diff --git a/content/1_Intro/Running_Code.mdx b/content/1_Intro/Running_Code.mdx
index 8e7a54f..0f9c6be 100644
--- a/content/1_Intro/Running_Code.mdx
+++ b/content/1_Intro/Running_Code.mdx
@@ -48,7 +48,7 @@ You can run your C++ programs from the command line and use a text editor of you
 
 <Resources>
   <Resource title="Sublime Text 3" url="https://www.sublimetext.com/" starred>
-    Fast, lightweight. Keeps asking you to purchase a license ...
+    Fast, lightweight. Unlimited free evaluation period, though it will repeatedly ask you to purchase a license.
   </Resource>
   <Resource title="Atom" url="https://atom.io/">
     From the makers of Github.
@@ -179,7 +179,7 @@ If you want to code in (neo)vim, you can install WSL and code through WSL bash.
 
     ```
     cd /usr/local/bin
-    ln -s g++-9 g++
+    ln -fs g++-9 g++
     ```
 
     `g++ --version` should now output the same thing as `g++-9 --version`.
@@ -228,15 +228,17 @@ See [Input & Output](./io) for how to do file input and output within the progra
 
 ### [Compiler Options (aka Flags)](https://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html)
 
-Use [compiler flags](https://developers.redhat.com/blog/2018/03/21/compiler-and-linker-flags-gcc/) to change the way GCC compiles your code. Usually, we use the following in place of `g++ name.cpp -o name`:
+Use [compiler flags](https://developers.redhat.com/blog/2018/03/21/compiler-and-linker-flags-gcc/) to change the way GCC compiles your code. Usually, we use something like the following in place of `g++ name.cpp -o name`:
 
-`g++ -std=c++17 -O2 name.cpp -o name -Wall -Wextra -Wshadow`
+```
+g++ -std=c++17 -O2 name.cpp -o name -Wall
+```
 
 Explanation:
 
 - `-O2` tells `g++` to compile your code to run more quickly (see [here](https://www.rapidtables.com/code/linux/gcc/gcc-o.html))
 - `-std=c++17` allows you to use features that were added to C++ in 2017. USACO currently uses `-std=c++11`.
-- `-Wall -Wextra -Wshadow` checks your program for common errors. See [Debugging](./debugging) for more information.
+- `-Wall` checks your program for common errors. See [Debugging](./debugging) for more information.
 
 You should always compile with these flags.
 
@@ -349,7 +351,7 @@ python3 --version # prints Python 3.8.1
 # Using an IDE
 
 <Resources>
-  <Resource source="IOI" title="2019 Contest Environment" url="https://ioi2019.az/en-content-26.html"> </Resource>
+  <Resource source="IOI" title="2019 Contest Environment" url="https://ioi2019.az/en-content-26.html">software you can use at IOI</Resource>
 </Resources>
 <LanguageSection>
 
@@ -363,18 +365,15 @@ These often have C++ support already built-in.
     url="https://code.visualstudio.com/"
     starred
   >
-    Lightweight, fast IDE, but requires some configuration. See{' '}
+    More lightweight than Visual Studio, requires some configuration. See{' '}
     <a href="http://www.csc.kth.se/~jsannemo/slask/main.pdf">PAPC 2.1</a> for
     setup instructions.
   </Resource>
-  <Resource source=" " title="Geany" url="https://www.geany.org/" starred>
+  <Resource source="Geany" title="Geany" url="https://www.geany.org/" starred>
     Lightweight, frequently used at IOI.
   </Resource>
-  <Resource source="Microsoft" title="Visual Studio" url="https://visualstudio.microsoft.com/vs/">
-    Heavier cousin of VS Code. VS Code is better for competitive programming.
-  </Resource>
-  <Resource source=" " title="Codeblocks" url="http://www.codeblocks.org/">
-    Bad on Mac.
+  <Resource source="Code::Blocks" title="Code::Blocks" url="http://www.codeblocks.org/">
+    Bad on Mac, <a href="https://codeforces.com/blog/entry/61780">apparently</a> unstable at IOI.
   </Resource>
   <Resource source="Apple" title="XCode" url="https://developer.apple.com/xcode/">
     Mac only.
@@ -388,6 +387,10 @@ These often have C++ support already built-in.
   </Resource>
 </Resources>
 
+<!--   <Resource source="Microsoft" title="Visual Studio" url="https://visualstudio.microsoft.com/vs/">
+    Heavier cousin of VS Code. VS Code is better for competitive programming.
+  </Resource> -->
+
 </CPPSection>
 
 <JavaSection>
diff --git a/content/2_Bronze/Ad_Hoc.mdx b/content/2_Bronze/Ad_Hoc.mdx
index 611a714..c7429f6 100644
--- a/content/2_Bronze/Ad_Hoc.mdx
+++ b/content/2_Bronze/Ad_Hoc.mdx
@@ -28,7 +28,7 @@ Any problem that doesn't fall under any well-defined category can be labelled as
 
 These tips are helpful in solving Ad Hoc problems. However, in the end, the best way to get better at Ad Hoc problems (or any type of problem) is to do a lot of them. Try to solve as many practice problems below as you can, and click the solution sketch tab if you can't figure the solution out.
 
-<!-- If anyone disagrees with any of the tips / ideas presented in the blogs below, just let me know and you can remove it if you want. I think they're quite interesting, though I haven't tried it out myself. -->
+<!-- If anyone disagrees with any of the tips / ideas presented in the blogs below, just let me know. I think they're quite interesting, though I haven't tried it out myself. -->
 
 <Resources>
   <Resource source="ZLE" title="The Art of Thinking" url="https://kauntaofficial.github.io/the-art-of-thinking">blog with more tips</Resource>
diff --git a/content/2_Bronze/Gen_Perm.mdx b/content/2_Bronze/Gen_Perm.mdx
index ecfac77..239b389 100644
--- a/content/2_Bronze/Gen_Perm.mdx
+++ b/content/2_Bronze/Gen_Perm.mdx
@@ -3,9 +3,9 @@ id: gen-perm
 title: "Generating Permutations"
 author: Darren Yao, Sam Zhang
 description: "Methods to generate all permutations of an array, a common technique associated with complete search."
-frequency: 4
+frequency: 1
 prerequisites:
- - complete-search
+ - intro-complete
 ---
 
 import { Problem } from "../models";
diff --git a/content/2_Bronze/Complete_Search.mdx b/content/2_Bronze/Intro_Complete.mdx
index b914942..0fc3dee 100644
--- a/content/2_Bronze/Complete_Search.mdx
+++ b/content/2_Bronze/Intro_Complete.mdx
@@ -1,8 +1,8 @@
 ---
-id: complete-search
-title: "Complete Search"
+id: intro-complete
+title: "Introduction to Complete Search"
 author: Darren Yao
-description: "Solving bronze problems by checking all possible cases in the solution space."
+description: "A basic example: iterating through all pairs."
 frequency: 4
 ---
 
@@ -117,4 +117,4 @@ A couple notes:
 
 ### Harder
 
-<Problems problems={problems.harder} />
+<Problems problems={problems.harder} />
\ No newline at end of file
diff --git a/content/4_Gold/BFS.mdx b/content/4_Gold/BFS.mdx
index deae5d0..ab4ab5f 100644
--- a/content/4_Gold/BFS.mdx
+++ b/content/4_Gold/BFS.mdx
@@ -199,7 +199,8 @@ Don't forget that once Bessie reaches the goal, she will ignore further commands
 
 </Warning>
 
-(Ben - equivalent to existing editorial)
+<!-- (Ben - equivalent to existing editorial) -->
+
 <!-- You can change it, but keep the section on making modifications to graphs before. Maybe replace with a problem w/o a good editorial? -->
 
 
diff --git a/content/4_Gold/DP.mdx b/content/4_Gold/DP.mdx
index fca485f..70db325 100644
--- a/content/4_Gold/DP.mdx
+++ b/content/4_Gold/DP.mdx
@@ -51,22 +51,16 @@ export const problems = {
     ],
 }
 
-**Dynamic Programming** (DP) is an important algorithmic technique in competitive programming that appears at all levels of competition. 
+**Dynamic Programming** (DP) is an important algorithmic technique in Competitive Programming from the gold division to competitions like the International Olympiad of Informatics. By breaking down the full task into sub-problems, DP avoids the redundant computations of brute force solutions.
 
-<IncompleteSection>
+Although it is not too difficult to grasp the general ideas behind DP, the technique can be used in a diverse range of problems and is a must-know idea for competitors in the USACO gold division.
 
-What do you mean by "all levels"? Certainly doesn't appear in silver ...
+<IncompleteSection>
 
 </IncompleteSection>
 
-By breaking down the full task into sub-problems, DP avoids the redundant computations of brute force solutions.
-
-Although it is not too difficult to grasp the general ideas behind DP, the technique can be used in a diverse range of problems and is a must-know idea for competitors in the USACO gold division.
-
 ## Introductory Resources
 
-Let's begin by reading some resources covering the basics of Dynamic Programming and introducing classical problems, or Dynamic Programming problems which are well known. <Asterisk> However, classical doesn't necessarily mean common. Since so many competitors know about these problems, problemsetters rarely set direct applications of them. </Asterisk>
-
 <Resources>
   <Resource source="CPH" title="7 - DP" starred>Great introduction that covers most classical problems. Mentions memoization.</Resource>
   <Resource source="TC" title="DP from Novice to Advanced" url="dynamic-programming-from-novice-to-advanced">great for all skill levels</Resource>
@@ -75,8 +69,6 @@ Let's begin by reading some resources covering the basics of Dynamic Programming
   <Resource source="PAPS" title="9 - DP">starts with DAGs, which are covered in "Topological Sort"</Resource>
 </Resources>
 
-Practice makes perfect. Start by doing some problems. Each topic starts with direct applications of the classical problems, and then some interesting variations and USACO problems which utilize the ideas. Solutions for most problems (excluding USACO) can be found on Chapter 7 of CPH.
-
 <Info title="Pro Tip">
 
 Sometimes it's a good idea to write a slower polynomial-time solution and then optimize it to the desired complexity (say, write $O(N^2)$ first and then speed it up to $O(N)$).
@@ -89,19 +81,23 @@ These are easier USACO problems which use DP, and don't require many optimizatio
 
 <Problems problems={problems.usacoEasy} />
 
-## Knapsack
+## Classical Problems
+
+Get familiar with some classical problems, or Dynamic Programming problems which are well known. <Asterisk> However, classical doesn't necessarily mean common. Since so many competitors know about these problems, problemsetters rarely set direct applications of them. </Asterisk> Solutions for most of these problems can be found in Chapter 7 of CPH.
+
+### Knapsack
 
 Common variations on Knapsack, followed by more challenging problems which feature variations on the state and additional algorithms.
 
 <Problems problems={problems.knapsack} />
 
-## Paths in a Grid (and related)
+### Paths in a Grid (and related)
 
 Interesting applications of "number of paths on a grid," some of which don't directly present a grid in the problem, but can be modelled as one. <Asterisk> Such as Longest Common Subsequence. </Asterisk> 
 
 <Problems problems={problems.pathsGrid} />
 
-## Longest Increasing Subsequence
+### Longest Increasing Subsequence
 
 Some of the problems in this section don't initially look like Longest Increasing Subsequence, but it ends up being the solution. <Asterisk> This can happen a lot, which is why it's a good idea to not focus on one topic unless you have a full solution</Asterisk>
 
diff --git a/content/4_Gold/Queues.mdx b/content/4_Gold/Queues.mdx
index 20a4a0f..66fe38a 100644
--- a/content/4_Gold/Queues.mdx
+++ b/content/4_Gold/Queues.mdx
@@ -95,7 +95,9 @@ d.push_front(1); // [1, 3, 7]
 d.pop_back(); // [1, 3]
 ```
 
+<IncompleteSection>
 (important: you can also access like array ...)
+</IncompleteSection>
 
 </CPPSection>
 
diff --git a/content/ordering.ts b/content/ordering.ts
index 8127c31..625eb67 100644
--- a/content/ordering.ts
+++ b/content/ordering.ts
@@ -76,9 +76,10 @@ const MODULE_ORDERING: {[key in SectionID]: Chapter[]} = {
     },
     {
       name: "Complete Search",
+      description: "Solving bronze problems by checking all possible cases in the solution space.",
       items: [
-        "complete-search",
-        "gen-perm",
+        "intro-complete",
+        "gen-perm"
       ]
     },
     {