Optimization AMPL中极小极大问题中如何求集的ArgMax

我有一个极大极小问题要在AMPL中解决。我有一系列处理器（

j

）和进程（

I

），每个进程在每个处理器上按顺序（从处理器1到处理器N）执行一组操作，每个操作的持续时间由

p[I，j]

每个进程都有一个预期的结束时间
任务是调度处理器上所有进程的执行，以最小化最大延迟（定义为执行结束的时间-预期结束时间）。为了做到这一点，正如您在下面的代码片段中所看到的，我尝试最小化约束中定义的max_延迟。问题是，这样做会使每一个延迟都变为最大延迟，从而造成糟糕的调度
你知道解决这个问题的另一种方法吗？我还考虑过设置

max\u delay>=argmax（delay[I]）

，但老实说，我不知道它是否正确，以及如何在AMPL中实现argmax函数

提前感谢您的回答，下面是我实现的代码

# Parameters
param r >= 0;                                                    # # of PROCESSORS
param T >= 0;                                                    # # of PROCESSES
param t_max >= 0;                                                # TIME max for TIME set

# Sets
set PROCESSES := 1..T;
set PROCESSORS := 1..r;
set TIME := 0..t_max;

# Other params
param D{PROCESSES} >= 0;                                          # exp. end
param p{PROCESSES, PROCESSORS} >= 0;                              # TIME for exec of operation p fro process i on processor j. 

# Variables
var USE{PROCESSES, PROCESSORS, TIME} binary;                
var end_time{PROCESSES} >= 0; 
var DELAY{i in PROCESSES} = end_time[i] - D[i];                   # array of delays
var max_DELAY integer >= 0;

# Constraints

# Constraint to define end_time
subject to end_time_constraint {i in PROCESSES}:
     sum{t in TIME} (t + p[i,r])*USE[i,r,t] <= end_time[i] ;

# constraint to grant a single execution 
subject to single_execution {i in PROCESSES, j in PROCESSORS} : 
    sum{t in TIME} USE[i,j,t]=1;

# Constraint to avoid multiple operation to execute at the same time
subject to operation_constraint {i in PROCESSES, t in TIME}:
    sum{j in PROCESSORS} USE[i,j,t]<=1;

# Constraint to grant the right execution order (operation od process i on processor j befor the one on j+1)
subject to order_constraint {i in PROCESSES, j in PROCESSORS, t in TIME}:
    sum{k in 0..t} USE[i,max(j-1, 1),k] >= USE[i,j,t];

# constraint to get the max delay over delays array

subject to max_DELAY {i in PROCESSES}:
    max_DELAY >= DELAY[i];

# constraint to avoid sovrapposition of processes
subject to non_sovrapp1 {t in TIME, j in PROCESSORS}:
    sum{i in PROCESSES, k in max(t-p[i,j]+1,0)..(t)} USE[i,j,k]<=1;

# constraint to avoid sovrapposition of processors
subject to non_sovrapp2 {i in PROCESSES, t in TIME} :
    sum{ j in PROCESSORS, k in max(t-p[i,j]+1,0)..(t)} USE[i,j,k] <= 1;

minimize min_DELAY : max_DELAY;

#参数
参数r>=0；##处理器数量
参数T>=0；##过程
参数t_max>=0；#时间设置的最大时间
#设置
设置进程：=1..T；
设置处理器：=1..r；
设定时间：=0..t_max；
#其他参数
参数D{PROCESSES}>=0；#实验结束
参数p{进程，处理器}>=0；#处理器j上进程i执行操作p的时间。
#变数
var使用{进程、处理器、时间}二进制；
var end_time{PROCESSES}>=0；
var DELAY{i in processs}=结束时间[i]-D[i]；#延迟数组
var max_延迟整数>=0；
#约束条件
#定义结束时间的约束
受结束时间约束{i in processs}：
和{t in TIME}（t+p[i，r]）*使用[i，r，t]=延迟[i]；
#避免进程位置变化的约束
根据时间上的非_sovrap1{t，处理器中的j}：
求和{i在过程中，k在最大值（t-p[i，j]+1,0）…（t）}使用[i，j，k]我们经常使用
min-max
和
min-sum
的组合。从本质上讲，这成为一个多目标问题，有标准的解决方法。一种方法是首先解决
min-max
问题，然后在
max
不恶化的情况下解决第二个
min-sum
。或者，使用加权和公式。有关某些详细信息（在不同的上下文中），请参阅