Combination of Teams Sets Algorithm - algorithm

Question

We have N students with M students per team, and for sure N is divisible by M. so a recursive combination would do the trick.
For example
N=6,N=2
12,34,56 is a combination
13,24,56 is another one
but the problem is that combinations generated can be repeated like
12,34,56
34,12,56
so is there any algorithm to generate non repeated sets of combinations ?
Also if i have an adjacency matrix like
S1 S2 S3 S4 S5 S6 S7 S8 S9
0 1 0 0 0 0 1 0 0 0
1 0 0 1 0 0 1 0 1 0
0 0 0 1 0 0 0 1 0 0
0 1 1 0 0 1 0 1 0 0
0 0 0 0 0 1 0 0 1 0
0 0 0 1 1 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0
0 1 0 0 1 0 0 0 0 1
0 0 0 0 0 1 0 0 1 0
Where 1's represents which student used to work with other students, can i generate the combinations where the max number of students in a team worked with each other equals m/2 at max ?

Answer 1

I think the best way to tackle this problem, is assigning each student a team number. So if you have 6 students, and the teams must be of 2 students, then you have to build 3 teams. So [0,0,1,1,2,2] could be the representation of how students are teamed.
That is an array of size 6 (the number of students), and the value in each position represents the assigned team number. If I understood correctly, you don't want to distinguish that team from [1,1,2,2,0,0] as the same students are teamed together.
The way I would do that, is assigning each student a team number, from left to right. The first student will always be in team 0, and for any other student only assign a team number up to one more than the max team number already used in the students at the left of the array. So [0,1,1,2,0,2] would be a candidate representation of how students are teamed, but [0,2,1,1,0,2] not, because student in position 1 is assigned to team 2, but the team 1 isn't started yet.
The code to create such teams could be something like:
IEnumerable<int[]> CombineTeams(int numberOfStudents, int teamSize) {
int numberOfTeams = numberOfStudents / teamSize;
int[] studentsInTeam = new int[numberOfTeams]; // used to avoid assigning more than teamSize students into a same team
studentsInTeam[0] = 1; // first student is initially assigned to team 0 from the start.
List<int[]> teams = new List<int[]>(); // here all the possible teams will be stored
int[] currentTeam = new int[numberOfStudents]; // used to assign the team numbers to studend
AssignTeams(teamSize, currentTeam, teams, 1, 0, studentsInTeam); // start assigning team numbers from the second student, as the first will always be in team 0
return teams;
}
void AssignTeams(int teamSize, int[] currentTeam, List<int[]> teams, int currentStudent, int maxTeam, int[] studentsInTeam) {
if (currentStudent == currentTeam.Length) {
int[] newTeam = new int[currentStudent];
for (int s = 0; s < currentStudent; s++)
newTeam[s] = currentTeam[s];
teams.Add(newTeam);
}
else {
for (int t = 0; t <= min(maxTeam+1, studentsInTeam.Length-1); t++) {
if (studentsInTeam[t] < teamSize) {
studentsInTeam[t]++;
currentTeam[currentStudent] = t;
AssignTeams(teamSize, currentTeam, teams, currentStudent+1, max(maxTeam, t), studentsInTeam);
studentsInTeam[t]--;
}
}
}
}
As this code creates all possible teaming combinations, there you'll find the one that maxes your teaming connections to M/2 if it exists (haven't give a thought to that last part). Hope this works for you.