Scoring for Imagine Cup Algorithm Round 2 is based on the performance of your submitted algorithm.

You will have until May 18, 2007 at midnight Pacific Standard Time (May 19th 07:00 AM GMT) to work on your algorithm. During this period you can test your algorithm as many times as you wish, using either a local test application or by uploading to the official benchmark server, and using a set of practice networks. After May 18, we will take the algorithm which you have designated as your best algorithm and run it against a final series of 16x16x16 networks. These final networks will be randomly generated, and their exact configuration will not be known in advance. Your final score will be determined by your algorithm’s performance against this final series of networks. The formula used will be

Score = ((Length / 1000) + Time) / NumNetworks

where

Length is the total length of edges in all 3D cubes your assembly returns, across all networks.

Time is the running time of your algorithm across all networks, in seconds, as measured on the benchmark server. This counts all time spent inside your OptimizeNetwork method, including any time required by calls you make to the simulation engine.

NumNetworks is the number of networks that the algorithm was run on. This is 1 when using the Client Runner and 20 when using the benchmark server.

The six contestants with the lowest (best) scores will advance to the finals.

Contestants must adhere to the following rules of competition, in addition to the general rules of the Imagine Cup Competition. We reserve the right to disqualify anyone who, in our opinion, has violated these rules.

1. All work must be exclusively that of the individual contestant.
2. Each contestant may work on and submit only one assembly (multiple accounts are not allowed).
3. Scores must be achieved only through the use of well-behaved .NET assemblies which focus exclusively on optimizing the total edge length and running time to optimize node placement. It is prohibited to attempt, by any means, to manipulate the operation or scoring on the benchmark server other than through such well-behaved assemblies.

Additionally, submitted assemblies must conform to the following restrictions:

1. The assemblies must be .NET 2.0 managed assemblies which expose a OptimizeNetwork() method.
2. The submitted algorithm must be "clean", defined as follows: They must use only a single execution thread on the processor and up to 256 MB of memory to determine the optimal node placement for a particular network. To the extent a submitted assembly achieves a higher score than other assemblies, it must do so based strictly on the quality of its algorithm, and in particular its ability to produce a more optimal node placement and/or do it in less time, operating in the same conditions as the other assembly.
   
   In particular, the following techniques are explicitly disallowed:

• Multithreaded solutions.
• Any access to machine resources other than the processor and memory, including files, registry, or network resources.
• Any technique which effectively calculates node placement for a particular network without being included in the timing results.
• Any saving of state across network runs.
• Any attempt to manipulate the runtime priority of the thread or of other machine processes.
• Any attempt to discover or manipulate the runtime environment of the assembly.
• Any attempt to manipulate assembly results and score other than via a "clean" algorithm, as defined above.


To help enforce this rule, contestants must supply buildable source for their assemblies on request.

2. Your assembly must conform to the following restrictions, when run on the benchmark server (for practice runs as well as the final run):

• Total "in process" time (time spent within your OptimizeNetwork method) must be less than 20 seconds per network.
• Total clock time for running your assembly must be less than 30 seconds per network.
• Total memory used by your assembly must be less than 256 MB.