解决一个有许多预先分配的作业

Question

我想解决的问题包括大约800项任务，必须分配给大约120名工人。工人必须有资格完成这项任务，并且每周只有一定的可用小时数。大约80%的作业已经预先分配好了。这意味着它们应该被保留，但如果其他20%的问题无法解决，则可能违反预先分配
我已经有了一个使用Choco solver的模型，如果违反了预先分配，该模型将使用惩罚，目标是最小化惩罚。然而，我认为这不是很有效，因为解算器不会通过分配预先分配的变量来启动搜索策略。我已经在这里专门针对Choco提出了这个问题（如何在Choco 3.3中定义传播起点）。

但是，有没有其他解决方案可以更容易地做到这一点？也许我最好自己写一个解决方案？如有任何建议，我将不胜感激。

编辑：我试着写我自己的巧克力策略。对于一个小问题，它工作得很好，但对于一个大问题，它找不到解决方案。我不确定我在getDecision中所做的一切是否都被允许（例如检查是否安装了），而且我找不到任何关于如何编写策略的文档或教程。如果有人能给我指点问题所在，我将不胜感激。（prios矩阵中的绝对优先级越高，变量分配的时间越早。如果优先级为负，则应分配0；如果优先级为正，则应分配1。最高优先级为9999）

    public class PriorityStrategy extends AbstractStrategy<IntVar> {

        int[] prios;

        // Search strategy parameters
        VariableSelector<IntVar> variableSelector;
        IntValueSelector valueSelectorLB;
        IntValueSelector valueSelectorUB;
        DecisionOperator<IntVar> decisionOperator;

        // object recycling management
        PoolManager<IntDecision> decisionPool;

        int currentIndex = -1;
        HashMap<IntVar, Integer> bestsMap = new HashMap<IntVar, Integer>();

        public PriorityStrategy(IntVar[] vars, int[] prios) {
            super(vars);
            this.prios = prios;
            valueSelectorLB = new IntDomainMin();
            valueSelectorUB = new IntDomainMax();
            variableSelector = new Random<IntVar>(123); //new Occurrence<IntVar>();
            this.decisionPool = new PoolManager<>();
        }

        @Override
        public Decision<IntVar> getDecision() {
             IntVar next = null;
             List<IntVar> bests = new ArrayList<IntVar>();

             int bestPrio = 0;
             for (int i = 0; i < vars.length; i++) {
                int currentPrio = Math.abs(prios[i]);
                if (currentPrio >= bestPrio && !vars[i].isInstantiated() || 
                        (next == null && !vars[i].isInstantiated())) {
                    if(currentPrio == 9999) {
                        currentIndex = i;
                        bests.clear();
                        bestsMap.clear();
                        return computeDecision(vars[i]);
                    }
                    if(currentPrio > bestPrio) {
                        bestPrio = currentPrio;
                        bests.clear();
                        bestsMap.clear();
                    }
                    bests.add(vars[i]);
                    bestsMap.put(vars[i], i);
                }
            }
            if(bests.size()>0) {
                next = variableSelector.getVariable(bests.toArray(new IntVar[bests.size()]));
                currentIndex = bestsMap.get(next);
            }
            return computeDecision(next);
        }

        @Override
        public Decision<IntVar> computeDecision(IntVar variable) {
            if (variable == null || variable.isInstantiated()) {
                return null;
            }
            int currentVal;
            if(prios[currentIndex] > 0){
                currentVal = valueSelectorUB.selectValue(variable);
            } else {
                currentVal = valueSelectorLB.selectValue(variable);         
            }
            System.out.println("Idx " + currentIndex);
            IntDecision current = decisionPool.getE();
            if (current == null) {
                current = new IntDecision(decisionPool);
            }
            current.set(variable, currentVal, DecisionOperator.int_eq);
            return current;
        }

    }

Answer 1

为什么不更改解算器的搜索策略，使其从预先指定的变量开始？文档中对此进行了描述。