General Comments:

  1. Try your program on the sample input and make sure they work!  If
     your program doesn't work on the sample input, it won't be accepted.
     (This is a necessary but not sufficient condition.)

  2. And make sure your program compiles!

  3. If you are going to try a brute force solution, look at the problem
     size and ask yourself whether it will finish in time.

  4. Make sure you handle all the valid test cases (look at the boundary
     conditions, look at the special cases, etc.).

  5. Read the question even if it looks long.  The problem may actually be
     easy to solve.

Problem A (Triangle War):

  Submissions:

  Total:               10
  In last 10 minutes:   4 (0 correct)
  Correct:              1

  Common Mistakes and Remarks:

  1. Not keeping track of the triangles and edges in an efficient manner,
     causing the program to run too long.
  2. Not stopping the search as soon as one side gets >= 5 triangles.

Problem B (Unscrambling Images):

  Submissions:         12
  In last 10 minutes:   2 (0 correct)
  Correct:              8

  Common Mistakes and Remarks:

  1. There were so few incorrect submissions...but we did catch someone
     not handling the case n = 1 correctly.

Problem C (A Plug for UNIX):

  Submissions:         84
  In last 10 minutes:  12 (0 correct)
  Correct:              2

  Common Mistakes and Remarks:

  1. Some teams tried a greedy algorithm: find a device and plug it in,
     repeat for as long as possible.  This doesn't work.
  2. Exhaustive search: this may give the correct answer, but we can't
     tell since the programs run for way too long.

Problem D (Treasure Hunt):

  Submissions:         16
  In last 10 minutes:  10 (0 correct)
  Correct:              1

  Common Mistakes and Remarks:

  1. Not much to say since most of the incorrect submissions are entries
     that print constant and/or random answers in the hope that they will
     get lucky.

  2. There is a straightforward O(n^5) algorithm, and then there is an 
     O(n^2) algorithm, and this can be further improved into O(n log n) 
     and O(n).

Problem E (487-3279):

  Submissions:        326
  In last 10 minutes:  38 (1 correct)
  Correct:             33

  Common Mistakes and Remarks:

  1. Allocating a character buffer of size 80, so 80-character lines are
     not handled.
  2. Not handling the "No duplicates." case.
  3. Use bubblesort or other slow sorting algorithms.  (Hint: use qsort()
     for C/C++ programmers, otherwise bring your own sort routine in
     hardcopy.)

Problem F (Biorhythms):

  Submissions:        253
  In last 10 minutes:   7 (1 correct)
  Correct:             65

  Common Mistakes and Remarks:

  1. Some solutions give answers that are 21252 days larger in some cases.
  2. Some teams did not handle the case when p, e, and i are not
     necessarily the first peaks.
  3. Some teams did not handle the case when p, e, and/or i are larger
     than d.
  4. Chinese remainder theorem can be used, but it's an overkill.

Problem G (Gone Fishing):

  Submissions:         34
  In last 10 minutes:  15 (0 correct) 
  Correct:              6

  Common Mistakes and Remarks:

  1. Exhaustive search takes way too long.

Problem H (The Same Game):

  Submissions:         23
  In last 10 minutes:   6 (2 correct)
  Correct:              5

  Common Mistakes and Remarks:

  1. Format error: extra spaces, capitalization, etc.
  2. Incorrect tie-breaking.