Question

我努力对我正在处理的问题进行分类，这意味着我无法弄清楚是否有任何已建立的启发式解决方案。您认为这是什么类型的问题，您会如何推荐我解决它？

我有一系列的水桶A，B，C，D。每个水桶都可以包含一定的水   东西的个数。水桶的总大小与水泥的大小相匹配   人口。人口中的项目每个都有A，B，C的得分，   d。

我想将项目分类到桶中，以便得分   匹配桶最大化;即所有项目的A分数   在桶A中，桶B中所有项目的B得分等等。它   因此，物品理想地可以在桶B中均匀   如果它的A分数更高，因为可能有许多项目具有高A   分数很少，B分数很高。

Answer 1

这看起来像minimum-cost maximum flow问题。实际上，这是最高成本，但可以通过否定权重来修正。

考虑以下网络。有一个来源s和一个接收器t。

每个项目i都由顶点u_i表示，边缘s -> u_i的容量为1，费用为0.

每个存储桶也由顶点表示：v_A v_B，依此类推。边缘v_A -> t的容量为A组的大小，成本为0，其他组的边缘类似。

最后，边缘u_i -> v_G的容量为1，成本等于（减去组i中放置项G的得分）。

观察此网络中的任何最大流量对应于项目分组，以便每个组具有给定的大小。

观察此网络中的最低成本最大流量是分区总分最大化的分区。

这可以很好地适应项目数量和组数。此外，这很容易扩展到组的大小可以变化到一定限度的情况，但每个项目仍然必须属于一个组。

Answer 2

对于足够小的尺寸，元启发式（如本地搜索）可能效果很好。

public class WeightedKnapsackProblem {

private int numberOfBins = 0;
private int numberOfItems = 0;

private int[][] scoreMatrix;
private int[] maxItemsPerBin;

public WeightedKnapsackProblem(int[][] score, int[] maxItemsPerBin){
    this.numberOfItems = score.length;
    this.numberOfBins = score[0].length;
    this.scoreMatrix = score;
    this.maxItemsPerBin = maxItemsPerBin;
}

public int score(int[] assignment){
    int s = 0;
    for(int i=0;i<numberOfItems;i++){
        int item = i;
        int bin = assignment[item];
        s += scoreMatrix[item][bin];
    }
    return s;
}

public int cost(int[] assignment){
    int c = 0;
    int[] tmp = new int[numberOfBins];
    for(int i=0;i<numberOfItems;i++){
        tmp[assignment[i]]++;
    }
    for(int i=0;i<numberOfBins;i++){
        if(tmp[i] > maxItemsPerBin[i])
            c++;
    }
    return c;
}

private java.util.Random RANDOM = new java.util.Random(System.currentTimeMillis());

private int[] mutate(int[] orig){
    int[] out = new int[orig.length];
    for(int i=0;i<orig.length;i++)
        out[i] = orig[i];
    out[RANDOM.nextInt(out.length)] = RANDOM.nextInt(numberOfBins);
    return out;
}

public int[] localSearch(){
    // initial assignment
    int[] a0 = new int[numberOfItems];
    for(int i=0;i<numberOfItems;i++)
        a0[i] = RANDOM.nextInt(numberOfBins);

    // max score for any item
    int max = scoreMatrix[0][0];
    for(int i=0;i<scoreMatrix.length;i++)
        for(int j=0;j<scoreMatrix[i].length;j++)
            max = java.lang.Math.max(max, scoreMatrix[i][j]);

    // local search
    int[] a1 = mutate(a0);
    int c0 = score(a0) - cost(a0) * max * max;
    int c1 = score(a1) - cost(a1) * max * max;
    for(int i=0;i<1000;i++){
        if(c1 > c0){
            a0 = a1;
            c0 = c1;
        }
        a1 = mutate(a0);
        c1 = score(a1) - cost(a1) * max;
    }

    // return
    return a0;
}

public int[] repeatedLocalSearch(int k){

    // max score for any item
    int max = scoreMatrix[0][0];
    for(int i=0;i<scoreMatrix.length;i++)
        for(int j=0;j<scoreMatrix[i].length;j++)
            max = java.lang.Math.max(max, scoreMatrix[i][j]);

    int[] a0 = localSearch();
    int c0 = score(a0) - cost(a0) * max * max;

    for(int i=0;i<k;i++){
        int[] a1 = localSearch();
        int c1 = score(a1) - cost(a1) * max * max;

        if(c1 > c0){
            c0 = c1;
            a0 = a1;
        }
    }

    return a0;
}
}

该程序基本上生成随机分配项目到垃圾箱，并迭代尝试改进初始情况。

因为使用这种技术很容易陷入局部优化，所以使用不同的（随机）启动配置重复几次是有意义的。

以下程序使用WeightedKnapsackProblem类生成可能的解决方案：

    int[][] score = {   {9,5,2,3},
                        {8,9,2,1},
                        {3,2,1,4},
                        {1,2,1,2},
                        {7,8,9,2},
                        {0,1,2,3}
                    };
    int[] maxItemsPerBin = {2,1,2,1};

    WeightedKnapsackProblem wkp = new WeightedKnapsackProblem(score, maxItemsPerBin);
    int[] assignment =  wkp.repeatedLocalSearch(10);

    System.out.println(wkp.score(assignment));
    System.out.println(wkp.cost(assignment));
    System.out.println(Arrays.toString(assignment));

打印出来：

34
0
[0, 1, 0, 3, 2, 2]

换句话说，可以解决演示问题，最高分为34 错放项目的数量（超过容量）将为0。

作业是：

第一个bin中的第一项
第二个箱子中的第二个项目
第一个箱子中的第三个项目
第四个箱子中的第四个项目
第三个箱子中的第五和第六项

加权装箱/背包优化

2 个答案: