Create a system to allocate students to supervisors and projects.

• Each supervisor has a ‘supervision load’ (number of students they can supervise) and proposes projects with different ‘multiplicities’ (maximum number of students per project).
• The system should ensure that the total project capacity per supervisor matches their load, and the total supervision capacity is enough for all students.

Based on this, an allocation of projects to students should be produced. The allocation produced must be legal. This means:

• Each student is allocated at most one project.
• The number of students allocated to a project does not exceed the multiplicity of that project.
• The total number of students allocated to a supervisor's proposed projects does not exceed the load of that supervisor.
• The allocation must also satisfy some local optimality requirements.

The allocation produced also has to satisfy some local optimality requirements. This means:

• Each student must be allocated a project, even if the allocated project is not on their preference list at all, unless no projects are available.
• No student should be allocated a project lower on their preference list (or not on their preference list at all) when there are other projects higher on their preference list that are not full.
• No two students would prefer swapping their allocated projects (i.e., both ranked the other student's allocated project higher in their own preference list).

• Each student getting his/her first choice gives a score of 4.
• Second choice a score of 3.
• Third choice a score of 2
• Fourth choice a score of 1
• And anything else gives a score of 0.

  The score of the allocation is the sum of all student scores.

My system uses a greedy algorithm to solve the project allocation system problem. The greedy algorithm works by iterating over the students in order of their preference lists and assigning each student to the highest-ranked project that is still available, subject to the constraints listed above.

./GenAlloc staff.txt projects.txt students.txt alloc.txt

All three input files are text files, each consisting of a number of lines. Each line represents a supervisor/project/student, and contains a number of fields separated by whitespace, as follows:

• Supervisor file: Each line consists of a supervisor id, followed by his/her load.
• Project file: Each line consists of a project id, then supervisor id, then multiplicity, and finally the project title.
• Student file: Each line consists of a student id, followed by up to four integers which are the project ids of this student's choices in descending order of preference. Note that some students may make fewer than four choices or even no choices at all.

The result of the allocation must be written to the named output file. (If the file already exists, it is quietly overwritten.)

Each line contains a student id, followed by a space, followed by the id of the allocated project.

These lines should be in increasing alphanumeric order (the standard C++ string comparison order) of the student userid. There must be a line for each student; if a student is not allocated any project, then 0 is used in place of the project id. Finally, there is another line containing a single integer, which is the score of the allocation.

The four files must be in this order in the command line arguments (staff, projects, students, output). All these files are assumed to be in the same directory as the executable program. Do not hardcode any other paths.