|
@@ -23,6 +23,9 @@ public class GreedySolver implements Solver {
|
23
|
23
|
final Priority priority;
|
24
|
24
|
|
25
|
25
|
final ArrayList<Task> tachesRestantes;
|
|
26
|
+ int[] machineFreeDate;
|
|
27
|
+ int[] jobFreeDate;
|
|
28
|
+
|
26
|
29
|
|
27
|
30
|
|
28
|
31
|
/** Creates a new greedy solver that will use the given priority. */
|
|
@@ -31,8 +34,12 @@ public class GreedySolver implements Solver {
|
31
|
34
|
this.tachesRestantes = new ArrayList<>();
|
32
|
35
|
}
|
33
|
36
|
|
|
37
|
+ private int getEarliestDate(Instance instance, Task task) {
|
|
38
|
+ return Math.max(machineFreeDate[instance.machine(task)], jobFreeDate[task.job]);
|
|
39
|
+ }
|
|
40
|
+
|
34
|
41
|
/** return true if t1 est plus prioritaire que t1 **/
|
35
|
|
- private boolean prioritaire(Instance instance, Task t1, Task t2) throws Exception {
|
|
42
|
+ private boolean prioritaire(Instance instance, Task t1, Task t2) {
|
36
|
43
|
boolean rt = false;
|
37
|
44
|
switch(priority) {
|
38
|
45
|
case SPT:
|
|
@@ -65,51 +72,107 @@ public class GreedySolver implements Solver {
|
65
|
72
|
rt = sigmaT1 >= sigmaT2;
|
66
|
73
|
break;
|
67
|
74
|
case EST_SPT:
|
68
|
|
- throw new Exception("UNKNOWN PRIORITY");
|
69
|
|
- //break;
|
|
75
|
+ if (getEarliestDate(instance, t1) < getEarliestDate(instance, t2)) {
|
|
76
|
+ rt = true;
|
|
77
|
+ } else if (getEarliestDate(instance, t1) > getEarliestDate(instance, t2)) {
|
|
78
|
+ rt = false;
|
|
79
|
+ } else {
|
|
80
|
+ rt = instance.duration(t1) <= instance.duration(t2);
|
|
81
|
+ }
|
|
82
|
+ break;
|
70
|
83
|
case EST_LPT:
|
71
|
|
- throw new Exception("UNKNOWN PRIORITY");
|
72
|
|
- //break;
|
|
84
|
+ if (getEarliestDate(instance, t1) < getEarliestDate(instance, t2)) {
|
|
85
|
+ rt = true;
|
|
86
|
+ } else if (getEarliestDate(instance, t1) > getEarliestDate(instance, t2)) {
|
|
87
|
+ rt = false;
|
|
88
|
+ } else {
|
|
89
|
+ rt = instance.duration(t1) >= instance.duration(t2);
|
|
90
|
+ }
|
|
91
|
+ break;
|
73
|
92
|
case EST_SRPT:
|
74
|
|
- throw new Exception("UNKNOWN PRIORITY");
|
75
|
|
- //break;
|
|
93
|
+ if (getEarliestDate(instance, t1) < getEarliestDate(instance, t2)) {
|
|
94
|
+ rt = true;
|
|
95
|
+ } else if (getEarliestDate(instance, t1) > getEarliestDate(instance, t2)) {
|
|
96
|
+ rt = false;
|
|
97
|
+ } else {
|
|
98
|
+ sigmaT1 = 0;
|
|
99
|
+ sigmaT2 = 0;
|
|
100
|
+ for (i=t1.task; i<instance.numTasks; i++) {
|
|
101
|
+ sigmaT1 += instance.duration(t1.job, i);
|
|
102
|
+ }
|
|
103
|
+ for (i=t2.task; i<instance.numTasks; i++) {
|
|
104
|
+ sigmaT2 += instance.duration(t2.job, i);
|
|
105
|
+ }
|
|
106
|
+ rt = sigmaT1 <= sigmaT2;
|
|
107
|
+ }
|
|
108
|
+ break;
|
76
|
109
|
case EST_LRPT:
|
77
|
|
- throw new Exception("UNKNOWN PRIORITY");
|
78
|
|
- //break;
|
|
110
|
+ if (getEarliestDate(instance, t1) < getEarliestDate(instance, t2)) {
|
|
111
|
+ rt = true;
|
|
112
|
+ } else if (getEarliestDate(instance, t1) > getEarliestDate(instance, t2)) {
|
|
113
|
+ rt = false;
|
|
114
|
+ } else {
|
|
115
|
+ sigmaT1 = 0;
|
|
116
|
+ sigmaT2 = 0;
|
|
117
|
+ for (i=t1.task; i<instance.numTasks; i++) {
|
|
118
|
+ sigmaT1 += instance.duration(t1.job, i);
|
|
119
|
+ }
|
|
120
|
+ for (i=t2.task; i<instance.numTasks; i++) {
|
|
121
|
+ sigmaT2 += instance.duration(t2.job, i);
|
|
122
|
+ }
|
|
123
|
+ rt = sigmaT1 >= sigmaT2;
|
|
124
|
+ }
|
|
125
|
+ break;
|
79
|
126
|
}
|
80
|
127
|
return rt;
|
81
|
128
|
}
|
82
|
129
|
|
83
|
|
- private void addTask(Instance instance, Task task) throws Exception {
|
84
|
|
- Iterator<Task> iter = this.tachesRestantes.iterator();
|
85
|
|
- int index = 0;
|
86
|
|
- boolean trouve = false;
|
87
|
|
- while (iter.hasNext() && !trouve) {
|
88
|
|
- Task current = iter.next();
|
89
|
|
- if (this.prioritaire(instance, task, current)) {
|
90
|
|
- trouve = true;
|
91
|
|
- } else {
|
92
|
|
- index++;
|
|
130
|
+ private void addTask(Instance instance, Task task) {
|
|
131
|
+ if (priority == Priority.SPT || priority == Priority.LPT || priority == Priority.SRPT || priority == Priority.LRPT) {
|
|
132
|
+ Iterator<Task> iter = this.tachesRestantes.iterator();
|
|
133
|
+ int index = 0;
|
|
134
|
+ boolean trouve = false;
|
|
135
|
+ while (iter.hasNext() && !trouve) {
|
|
136
|
+ Task current = iter.next();
|
|
137
|
+ if (this.prioritaire(instance, task, current)) {
|
|
138
|
+ trouve = true;
|
|
139
|
+ } else {
|
|
140
|
+ index++;
|
|
141
|
+ }
|
93
|
142
|
}
|
|
143
|
+ this.tachesRestantes.add(index, task);
|
|
144
|
+ } else {
|
|
145
|
+ this.tachesRestantes.add(task);
|
94
|
146
|
}
|
95
|
|
- this.tachesRestantes.add(index, task);
|
96
|
147
|
}
|
97
|
148
|
|
98
|
|
- private Task getTask() {
|
99
|
|
- return this.tachesRestantes.remove(0);
|
|
149
|
+ private Task getTask(Instance instance) {
|
|
150
|
+ if (priority == Priority.SPT || priority == Priority.LPT || priority == Priority.SRPT || priority == Priority.LRPT) {
|
|
151
|
+ return this.tachesRestantes.remove(0);
|
|
152
|
+ } else {
|
|
153
|
+ int indexBest = 0;
|
|
154
|
+ int indexChallenger;
|
|
155
|
+ for (indexChallenger = 1; indexChallenger < tachesRestantes.size(); indexChallenger++) {
|
|
156
|
+ if (prioritaire(instance, tachesRestantes.get(indexChallenger), tachesRestantes.get(indexBest))) {
|
|
157
|
+ indexBest = indexChallenger;
|
|
158
|
+ }
|
|
159
|
+ }
|
|
160
|
+ return this.tachesRestantes.remove(indexBest);
|
|
161
|
+ }
|
100
|
162
|
}
|
101
|
163
|
|
102
|
164
|
@Override
|
103
|
165
|
public Result solve(Instance instance, long deadline) {
|
104
|
166
|
//Initialisation
|
|
167
|
+ jobFreeDate = new int[instance.numJobs];
|
|
168
|
+ machineFreeDate = new int[instance.numMachines];
|
105
|
169
|
int i;
|
106
|
170
|
for (i=0; i<instance.numJobs; i++) {
|
107
|
|
- try {
|
108
|
|
- this.addTask(instance, new Task(i,0));
|
109
|
|
- } catch (Exception e) {
|
110
|
|
- System.out.println("ERREUR POLITIQUE DE PRIORITE INCONNUE");
|
111
|
|
- System.exit(2);
|
112
|
|
- }
|
|
171
|
+ this.addTask(instance, new Task(i,0));
|
|
172
|
+ this.jobFreeDate[i] = 0;
|
|
173
|
+ }
|
|
174
|
+ for (i=0; i<instance.numMachines; i++) {
|
|
175
|
+ this.machineFreeDate[i] = 0;
|
113
|
176
|
}
|
114
|
177
|
ResourceOrder resourceOrder = new ResourceOrder(instance);
|
115
|
178
|
Task task;
|
|
@@ -117,16 +180,14 @@ public class GreedySolver implements Solver {
|
117
|
180
|
|
118
|
181
|
//Itérations
|
119
|
182
|
while (!this.tachesRestantes.isEmpty()) {
|
120
|
|
- task = this.getTask();
|
|
183
|
+ task = this.getTask(instance);
|
|
184
|
+ int startTime = getEarliestDate(instance, task);
|
121
|
185
|
resourceOrder.addTaskToMachine(instance.machine(task), task);
|
|
186
|
+ this.machineFreeDate[instance.machine(task)] = startTime + instance.duration(task);
|
|
187
|
+ this.jobFreeDate[task.job] = startTime + instance.duration(task);
|
122
|
188
|
nextTask = instance.nextTask(task);
|
123
|
189
|
if (nextTask != null) {
|
124
|
|
- try {
|
125
|
|
- this.addTask(instance, new Task(task.job, task.task + 1));
|
126
|
|
- } catch (Exception e) {
|
127
|
|
- System.out.println("ERREUR POLITIQUE DE PRIORITE INCONNUE");
|
128
|
|
- System.exit(2);
|
129
|
|
- }
|
|
190
|
+ this.addTask(instance, new Task(task.job, task.task + 1));
|
130
|
191
|
}
|
131
|
192
|
}
|
132
|
193
|
return new Result (instance, resourceOrder.toSchedule(), ProvedOptimal);
|