问题描述

给定n个设备和m个顾客

• 每个顾客有一定的需求(demand)需要被设备满足，记为d[i]
• 每个设备有不同的满足顾客需求的容量(capacity)，记为c[j]
• 每个设备有不同的开启费用(opening cost)，记为o[j]
• 不同顾客分配到不同设备会有不同的分配费用(assignment cost)，记为a[i][j]

现在所要达成的目的是要满足所有顾客的要求，同时使opening cost和assignment cost的总和(total cost)最小。问：

1. 最终哪些设备要开启？
2. 对所有顾客的最终分配方案是怎么样的？

分析

m个顾客会有n中不同的选择，如果我们要穷尽所有的可能，时间复杂度将会是 O(n^m)，显然这不是一个很好的选择；所以我们应该采取更优的做法。

首先先写出主程序框架:

int main(){

    for(int testCase = 1; testCase <= 71; testCase ++){

        // Data declaration
        int n, m;   // n facilities, m customers
        int* d;     // demands of customers
        int* c;     // capacities of facilities
        int* o;     // opening cost of facilities
        int** a;    // assignment cost for each (cus, fac)

        bool* open_state;   // result: open state of facilities
        int* assign_state;  // result: assignment of cus->fac
        
        // Load files
        ifstream infile;
        char filename[32];
        sprintf_s(filename, "Instances\\p%d", testCase);
        infile.open(filename, ios::in);

        if(!infile.is_open ()){
            cout << "Open file failure: " << filename <<  endl;
            continue;
        }

        infile >> n >> m;
        c = new int[n];
        o = new int[n];
        for(int i = 0; i < n; ++i){
            infile >> c[i] >> o[i]; 
        }
        d = new int[m];
        a = new int*[m];
        for(int i = 0; i < m; ++i){
            a[i] = new int[n];
            infile >> d[i];
        }

        for(int i = 0; i < m; ++i){
            for(int e = 0; e < n; ++e){
                infile >> a[i][e];
            }
        }
        infile.close();

        open_state = new bool[n];
        for(int i = 0; i < n; ++i) open_state[i] = false;
        assign_state = new int[m];
        
        // Calculate
        int result = Algorithm(n,m,d,c,o,a,open_state,assign_state);

        // Output Results
        sprintf_s(filename, "results\\greedy\\p%d", testCase);
        ofstream outfile(filename);
        if(result == -1){
            outfile << "No result" << endl;
            continue;
        }
        outfile << result << endl;
        for(int i = 0; i < n; ++i)
            outfile << open_state[i] << ' ';
        outfile << endl;
        for(int i = 0; i < m; ++i)
            outfile << assign_state[i] << ' ';
        outfile << endl;

        // Release space
        for(int i = 0; i < m; ++i){
            delete[] a[i];
        }
        delete[] c, o, open_state, assign_state;
    }
}

贪心算法

首先比较容易想到的是贪心算法。按照逐个顾客分配的办法，每次为顾客进行分配的时候，需要找到为他分配设备的最小花费，这有可能是：

• 无需重新分配新的设备，花费总额为 a[i][j]
• 分配新的设备，花费总额为 c[j]+a[i][j]

值得一提的是，贪心算法大概率不是最优算法，甚至有可能会有在原本有解的情况下算出无解的答案。但其优点是会比较快。

#include <iostream>
#include "greedy.hpp"
using namespace std;

int Greedy(int n, int m, int *d, int *c, int *o, int **a, bool *os, int* as){

    int tc = 0;
    for(int curCus = 0; curCus != m; ++curCus){
        int minCost = INT32_MAX;
        int curChoice = -1;
        for(int curFac = 0; curFac != n; curFac++){
            if(d[curCus] <= c[curFac]){
                int tempCost = a[curCus][curFac];
                tempCost += os[curFac] ? 0 : o[curFac];
                if(tempCost < minCost){
                    minCost = tempCost;
                    curChoice = curFac;
                }
            }
        }
        if(curChoice == -1)
            return -1;
        
        os[curChoice] = true;
        as[curCus] = curChoice;
        c[curChoice] -= d[curCus];
        tc += minCost;
    }
    return tc;
}

运算结果：

具体的分配结果可见github仓库

贪心算法V1

在上面的算法中，我们取p1的结果为例:

18076
1 1 1 1 0 1 1 0 1 1 
1 1 1 8 1 9 8 9 8 9 9 9 9 9 9 9 5 9 9 5 5 5 5 5 5 5 5 5 5 0 3 0 5 0 3 0 0 3 0 0 0 3 3 3 8 3 3 2 2 6 

我们可以发现使用贪心算法，顾客倾向于不开新的设备，因为新开设备要加上开设备的费用。可以理解到，每个顾客都把开某个设备的费用算到了自己头上，就像滚烫的山芋不愿意握在手上；但实际上开设备的费用最终是落到总费用上，所以我们可以试一下顾客不去考虑开工厂的费用，到最后再去算。

代码和上面类似V1版本的类似，只有一些细微的修改

// 删去这行
tempCost += os[curFac] ? 0 : o[curFac];
// 增加这个
if(!os[curChoice]){
    minCost += o[curChoice];
    os[curChoice] = true;
}

结果：