Question

我正在为作业设计算法，我不确定我是否编写了正确的算法，请您指导我？问题是：有n个学生S1，S2，...，Sn和n等级：G1，G2，...... Gn。每个学生必须被分配到一个年级，并且只有一个学生被分配到任何一个年级。如果Tij是将Si分配给Gj的值，我必须找到最大的T的Q子集。（我必须指派工人做最好的工作）这个问题的一个例子是，如果我有两个学生S1和S2，并且我有2个等级G1和G2，我有例如T12 = 12，T21 = 7，T11 = 9，T22 = 16子集必须是Q = {T12，T22} 我编写了以下算法（在java中）：

   Algorithm studentG(J[],W[],V[][],x[][])
 {
     // I use heap data structure for solving this problem
     // initial all x[][] = 0
      ArrayList<Heap> students = new ArrayList<Heap>();
      students = Heap(v[][]); // this method make a heap for each student,

     for(int k = 0; k< J.length, k++)
   {
  Boolean test = false;
  // this loop is for each student to assign each student to only one grade not more.
  for(int m = 0; m< students.size(); m++)
 {
If(students.get[m].root.getGrade() ==k && test == false){
test = true;
//I have assigned 1 to the feasible and 0 othrwise
 x[m][k] = 1;
}else if(students.get[m].root. getGrade() != k){
 Continue;
}else if(students.get[m].root. getGrade() == k && test == true){
 students.get[m].remove(root);
 students.get[m].heapify();
 }
}
}

这有效吗？感谢。

Answer 1

您要解决的问题实际上是对travelling salesman problem的重新定义，Google将为您提供许多可能的算法来解决它。

您的算法无法分配成绩，没有优化。您也可以按顺序学习成绩和学生，然后将每个成绩分配给另一个。这将为解决方案产生一个可能的设置，但它（可能，1个机会）不是最佳的。

在实现算法之前，尝试用伪语言表达它。算法的简单实现可能如下所示：

foreach student S do
  foreach unassigned grade G do
    Add {G, S} to the solutions
    Compute the solution score
    If (this score > greater score so far) Then 
      Keep solution like this
      Mark G as assigned
    Else 
      Remove {G, S} from the solution
  Next
Next

就数据结构而言，您可以使用Java：

// The number of grades and students
public static final int N = 10;

// The students and grades are just a suite of numubers
List<int> students = new ArrayList<int>(N);
List<int> grades = new ArrayList<int>(N);    
for (int i=0; i<N; ++i) {
  students.set(i, i);
  grades.set(i, i);
}

// Each score for a possible pair of grade student is stored in a matrix 
int[][] scores = new int[N][N];
for (int s=0; s<N; ++s) {
  for (int g=0; g<N; ++g) {
    scores[s][g] = students.get(s) * grades.get(g);
  }
}

// An association of student and grade
class Association {
  int student;
  int grade;
  int score;
  public Association(int student, int grade, int score) {
    this.student = student;
    this.grade = grade;
    this.score = score;
  }
}

// The solution
Stack<Association> solution = new Stack<Association>(N);

我将让您尝试使用这些数据结构实现上述算法，使用Stack.push和Stack.pop添加/删除解决方案和List.remove中的关联，以标记解决方案中使用的等级。

不要忘记实现一个计算当前解决方案中得分总和的函数（可能类似于：public int getSolutionScore（Stack solution））

Answer 2

@Samuel：“每个学生必须被分配到一个年级，而且只有一个学生被分配到任何一个年级。”

这意味着具有将学生映射到任何等级S-> G的功能。这个条件似乎没有引入边约束（即所有成绩必须在学生集中以最佳方式分配，同时保持1对1的约束。）

所以从本质上讲（如果问题确实是正确的），这意味着只需选择

所有我的

Q = argmax_j（Tij）。

这只是成本矩阵T 每行的最大值。

我想我不必提供代码示例，因为找到最大元素是O（n）的一个相当简单的操作。如果你愿意，可以使用堆，但是简单的扫描和保持最大值也可以。

由于这看起来太简单了，问题可能是错误的。

Answer 3

你的例子不清楚。不选择T12和T22会违反您的条件（即有两名学生被分配到2年级）。

帮助编写算法

3 个答案: