Optaplanner 异常：selectionList 包含 2 次相同的选择

Question

我有这个问题，在构建我的问题实现之后，当运行 Optaplanner:

java.lang.IllegalStateException: The selectionList contains 2 times the same selection (Edge to: MinMax1 from: s4,s5,) and (Edge to: Sum2 from: s3,s4,).
at org.optaplanner.core.impl.heuristic.selector.common.decorator.WeightFactorySelectionSorter.sort(WeightFactorySelectionSorter.java:58)
at org.optaplanner.core.impl.heuristic.selector.entity.decorator.SortingEntitySelector.constructCache(SortingEntitySelector.java:44)

我已阅读中的问题，但没有对象是 null。我修改了 Entity class，即 Edge，以实现 AbstractPersistable，在此之前，我尝试覆盖 equals() 方法，结果相同：

@PlanningEntity(difficultyWeightFactoryClass = EdgeDifficultyWeightFactory.class)
public class Edge extends AbstractPersistable{

/**
 * 
 */
private ArrayList<Node> from;
private Node to;
private double burstTime;


private BufferSize size;

public Edge(){
    from = new ArrayList<Node>();
    BufferSize p = new BufferSize();
    p.setSize(1);
    this.size = p;
            //new Random().nextInt(1000)+1;
    this.burstTime += this.size.getSize();
}

public void setFrom(Node from){
    this.from.add(from);
    this.calculateEdgeBurstTime();
}

public ArrayList<Node> getFrom(){
    return from;
}

public void setTo(Node to){
    this.to = to;
}

public Node getTo(){
    return to;
}

@PlanningVariable(valueRangeProviderRefs = {"bufferRange"})
public BufferSize getBufferSize(){
    return size;
}

public void setBufferSize(BufferSize size){
    this.size = size;
    System.out.println("Size has been set: "+size);
    this.calculateEdgeBurstTime();
}

public void calculateEdgeBurstTime(){
    for(Node node : this.from){
        this.burstTime+=this.size.getSize()*node.getNodeTime();
    }
}

public double getEdgeTime(){
    return burstTime;
}

@Override
public String toString(){
    StringBuffer sb = new StringBuffer();
    sb.append("Edge to: "+to.getID()+" from: ");
    for(Node node : this.from){
        sb.append(node.getID()+",");
    }
    return sb.toString();
}

@Override
public boolean equals(Object other){
    if (other == null) return false;
    if (other == this) return true;
    if (!(other instanceof Edge))return false;
    Edge otherMyClass = (Edge)other;
    boolean checkFrom = true;
    if(!(otherMyClass.getTo().getID().equals(this.getTo().getID()))) return false;
    for(Node node : otherMyClass.getFrom()){
        for(Node nd : this.getFrom()){
            if(!(node.getID().equals(nd.getID()))){
                checkFrom = false;
            }
        }
    }
    System.out.println("checked "+checkFrom+this.toString());
    return checkFrom;
}

@Override    
public int hashCode(){
    HashCodeBuilder builder = new HashCodeBuilder();
    builder.append(this.to.getID());
    builder.append(this.from);
    return builder.toHashCode();
}

}

为了更好的说明问题，我的EdgeDifficultyWeightclass是这样实现的：

public class EdgeDifficultyWeightFactory implements SelectionSorterWeightFactory<SmartNodeGraph,Edge>{

public Comparable createSorterWeight(SmartNodeGraph graph, Edge edge) {

    int difficulty = edge.getFrom().size(); //Edges with more dependencies are more difficult to plan
    if(edge.getTo() instanceof NetworkNode){
        difficulty += difficulty; //Edges to NetworkNodes are more difficult to plan.
    }
    for(Node node : edge.getFrom()){
        if(node instanceof ProcessingNode){
            difficulty +=2; //If precedes form ProcessingNode is more difficult to optimise than sensors directly
        }else if(node instanceof SensorNode){
            difficulty +=1;
        }
    }
    return new EdgeDifficultyWeight(edge,difficulty);
}

public class EdgeDifficultyWeight implements Comparable<EdgeDifficultyWeight> {

    private final Edge edge;
    private final int difficulty;

    public EdgeDifficultyWeight(Edge edge, int difficulty){
        this.edge = edge;
        this.difficulty = difficulty;
    }

    public int compareTo(EdgeDifficultyWeight arg) {
        return new CompareToBuilder().append(arg.difficulty, this.difficulty).toComparison();
    }

    }

}

规划问题是这样的：我有几个分开的Tree结构，每棵树的Root节点都有一个ready时间，这个时间取决于所有providers节点。我想让所有根节点时间相等，树的每条边都有一个缓冲区，可以修改大小以更改父节点的时间。通过更改几个边上的缓冲区，我想让所有树的根级别的时间都相等。

关于解释，具有更多节点（以及其他约束）的边更难以分配。使用调试器，问题似乎出在这一行：

Comparable difficultyWeight = selectionSorterWeightFactory.createSorterWeight(solution, selection);

Comparable 对象始终相同。

有人可以帮忙吗？

Answer 1

在EdgeDifficultyWeight中加入.append(arg.edge.getId(), this.edge.getId())，区分2个边缘不同但难度相同的权重

public class EdgeDifficultyWeight implements Comparable<EdgeDifficultyWeight> {

    private final Edge edge;
    private final int difficulty;

    public EdgeDifficultyWeight(Edge edge, int difficulty){
        this.edge = edge;
        this.difficulty = difficulty;
    }

    public int compareTo(EdgeDifficultyWeight arg) {
        return new CompareToBuilder()
                .append(arg.difficulty, this.difficulty)
                .append(arg.edge.getId(), this.edge.getId())
                .toComparison();
    }

}

Optaplanner 异常：selectionList 包含 2 次相同的选择

Optaplanner exception: the selectionList contains 2 times the same selection

java

optaplanner