first commit

Core/Calculation/TeamScheduler_DecisionTree.cs

@@ -0,0 +1,101 @@
+using Core.Entities;
+
+namespace Core.Calculation;
+public class TeamScheduler_DecisionTree
+{
+	private readonly IList<Student> _students;
+	private readonly IList<Team> _teams;
+
+	private readonly int _timeSlotCount;
+
+	public TeamScheduler_DecisionTree(IList<Team> teams, int timeSlotCount)
+	{
+		_timeSlotCount = timeSlotCount;
+		_teams = teams;
+		_students = teams.SelectMany(t => t.Students).Distinct().ToList();
+	}
+
+	public IList<Team>[] Solve()
+	{
+		var timeSlots = new IList<Team>[_timeSlotCount];
+		for (var i = 0; i < _timeSlotCount; i++)
+			timeSlots[i] = new List<Team>();
+
+		foreach (var team in _teams.OrderByDescending(t => t.Students.Count))
+		{
+			// get overlapping students in each timeslot
+			var overlaps
+				= (from tsi in Enumerable.Range(0, timeSlots.Length)
+					let ts = timeSlots[tsi]
+					let tss = ts.SelectMany(t => t.Students).Distinct()
+					select Tuple.Create(tsi, team.Students.Count(tss.Contains)))
+				.OrderBy(t => t.Item2)
+				.ThenBy(t => timeSlots[t.Item1].Count);
+
+			timeSlots[overlaps.First().Item1].Add(team);
+		}
+		return timeSlots;
+	}
+
+	public IList<Team>[] SolveRecursive()
+	{
+		// initialize time slots
+		var timeSlots = new IList<Team>[_timeSlotCount];
+		for (var i = 0; i < _timeSlotCount; i++)
+			timeSlots[i] = new List<Team>();
+
+		return
+			(from i in Enumerable.Range(1, 5)
+			 let solution = Recursive(timeSlots, _teams, i)
+			 let overlapCount = Team.GetStudentTeamOverlapCount(solution)
+			 orderby overlapCount
+			 select solution).First();
+	}
+
+	private static IList<Team>[] CopyTimeSlots(IList<Team>[] timeSlots)
+	{
+		return timeSlots.Select(ts => (IList<Team>)new List<Team>(ts)).ToArray();
+	}
+
+	private static IList<Team>[] Recursive(IList<Team>[] timeSlots, IList<Team> teams, int overlapTriesStudents = 4)
+	{
+		if (!teams.Any())
+			return timeSlots;
+			
+		var overlapsTries = 
+			(from team in teams.OrderByDescending(t => t.Students.Count).Take(overlapTriesStudents) 
+			//from ts in timeSlots
+			from tsi in Enumerable.Range(0, timeSlots.Length)
+			let ts = timeSlots[tsi]
+			let tss = ts.SelectMany(t => t.Students)
+			select Tuple.Create(ts, tsi, team, team.Students.Count(tss.Contains)))
+			.OrderBy(t => t.Item4)
+			.ThenBy(t => t.Item1.Count);
+
+		var minOverlaps =
+			(from o in overlapsTries
+			group o by o.Item4
+			into oo
+			orderby oo.Key
+			select oo).First();
+
+		var first = minOverlaps.First();
+
+		var results = new List<Tuple<IList<Team>[], int>>();
+
+		foreach (var minOverlap in minOverlaps)
+		{
+			var timeSlotsAfterAdd = CopyTimeSlots(timeSlots);
+			timeSlotsAfterAdd[first.Item2].Add(first.Item3);
+			var remainingTeams = teams.Where(t => t != first.Item3).ToList();
+
+			var result = Recursive(timeSlotsAfterAdd, remainingTeams);
+
+			results.Add(Tuple.Create(result, Team.GetStudentTeamOverlapCount(result)));
+			if (minOverlap.Item4 == 0)
+				break;
+		}
+
+		return results.OrderByDescending(r => r.Item2).First().Item1;
+	}
+}