Algorithm 分支绑定实现

我一直在研究这个问题，我可以得到一些结果，但在这里实现分支定界方法时遇到了问题。
你们能帮帮我吗

建造仓库

描述

中了彩票后，你决定 买几辆卡车。 您的目标是向所有人交付商品 科英布拉的超市。但是现在你 必须建造仓库来储存货物 商品，你必须考虑 可能的地点。理想情况下 仓库的位置应靠近 为了减少开支，超市停止营业 运输费用。然而，你 不能把所有的钱都花在建筑上 到处都是仓库，所以你必须 做出一个聪明的决定：考虑到 建造每个仓库的固定成本 在每个可能的位置和 每次服务的运输费用 从超市里的每个位置 未来5年，你想知道在哪里 仓库的建造应确保 总成本（运输和固定成本） 该期间的成本）是最低的。 请注意，至少必须有一个仓库 建造。此外，计算 总的运输成本必须降低 考虑到这一切 超市必须提供服务

输入

每个测试用例都包含信息 关于建筑的固定成本 指定地点的仓库和 与每个项目相关的运输成本 地点和超市。第一 每个测试用例的行给出了 可能出现以下情况的位置的数量： 可以建立仓库（nnodes=malloc（新建集->容量*sizeof（int））； mins=malloc（（超市+1）*sizeof（国际））； /* 对于（i=0；isize；i++）{ printf（“%d”，集合->节点[i]）； } printf（“\n”）*/ 对于（j=0；j<1；j++）{ 分钟[j]=整数最大值； } 成本=0； 对于（i=0；isize；i++）{ t=设置->节点[i]； 成本+=矩阵[t][0]； 对于（j=1；j<1；j++）{ if（分钟[j]>矩阵[t][j]）{ mins[j]=矩阵[t][j]； } } } 对于（j=1；j<1；j++）{ 成本+=分钟[j]； } 免费（分钟）； memcpy（new_set，set，sizeof（struct set））； memcpy（新建集合->节点，集合->节点，集合->容量*sizeof（int））； 如果（成本<*更低）{ *更低=成本； } 如果（设置->位置<设置->容量）{ 设置->节点[设置->大小]=设置->位置； 设置->大小++； 设置->位置++； 计算客户（矩阵、集合、较低）； } 如果（新设置->位置<新设置->容量）{ 新建集合->节点【新建集合->大小-1】=新建集合->位置； 新建_集合->位置++； 计算客户（矩阵，新集合，更低）； } } int main（int argc，const char*argv[] { int t； int i，j； int较低； int**矩阵； /*分配矩阵*/ scanf（“%d”和位置）； scanf（“%d”&超市）； 矩阵=malloc（位置*sizeof（int*）； 对于（i=0；i<位置；i++）{ 矩阵[i]=malloc（（超级市场+1）*sizeof（int））； } 结构集*set； set=malloc（sizeof（struct set））； set->nodes=malloc（位置*sizeof（int））； 设置->大小=1； 设置->位置=1； 设置->容量=位置； 设置->节点[0]=0； 对于（i=0；i<位置；i++）{ 对于（j=0；j<1；j++）{ scanf（“%d”、&t）； 矩阵[i][j]=t； } } 下限=整数最大值； 计算客户（矩阵、集合和更低）； printf（“%d\n”，较低）； 返回0； }

---

我不清楚标准分支和绑定是否能在这里工作

BnB的工作原理是，当s扩展到完整解决方案的成本无法提高到目前为止找到的最佳完整解决方案的成本时，强制搜索回溯到部分解决方案s。这取决于能够说明任何部分解决方案s的成本下限

在这个问题中，对部分解决方案的一步扩展要么会提高总体成本，要么会降低总体成本（如果它使运送到超市的成本比建造额外仓库的成本更低），这使得下限语句很难用有用的方式表述。

是正确的--“普通”B&B在这里不起作用，因为分数可能上升或下降。但问题中仍有一些结构可以利用

任何非空仓库集都会产生一个（可能是非最优的）解决方案。给定解决方案的总成本是建造所有仓库的成本加上为所有超市提供服务的成本。给定一组仓库，显然每个超市都应该由该超市的最低成本仓库提供服务。请注意，在向解决方案中添加仓库时，为给定仓库提供服务的成本保持不变或减少

需要注意的一点是，如果向解决方案中添加仓库会增加总成本，那么就永远不值得了。为什么

如果这是添加到解决方案中的最后一个仓库，那么显然它会增加总成本，因此不应添加

否则，假设这是Ki＞i仓库中的第i个仓库。考虑在最后一个地方而不是第1个地方添加的解决方案——可以添加这个仓库，然后可能降低总成本吗？不，因为对于每个超市S，每个步骤中添加的i + +….. k的每一个仓库都会降低服务的成本。与目前的解决方案相比，增加一个仓库能够产生净收益的唯一方法是能够以更便宜的价格为一个或多个超市提供服务。如果在添加第一个i-1步骤后不是这样，那么在完整解决方案中添加所有k-1其他仓库后肯定不会是这样。这意味着在以后时间添加仓库的净成本始终与在较早时间添加仓库的净成本相同或更差 这可能会修剪头发

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

struct set {
    int *nodes;
    int position;
    int size;
    int capacity;
};

int locations;
int supermarkets;





void calc_custo(int **matrix, struct set *set, int *lower){


    int i;
    int last;
    int cost;
    int t;
    int j;
    int *mins;
    struct set *new_set;
    new_set = malloc(sizeof(struct set));
    new_set->nodes = malloc(new_set->capacity * sizeof(int));

    mins = malloc((supermarkets + 1) * sizeof(int));
    /*
    for (i = 0; i < set->size; i ++) {
        printf("%d ", set->nodes[i]);
    }
    printf("\n");*/
    for(j = 0; j < supermarkets + 1; j++) {
        mins[j] = INT_MAX;
    }   

    cost = 0;
    for(i = 0; i < set->size; i ++) {
        t = set->nodes[i];
        cost += matrix[t][0];
         for(j = 1; j < supermarkets + 1; j++) {
             if (mins[j] > matrix[t][j]) {
                 mins[j] = matrix[t][j];
             }

         }
    }

    for(j = 1; j < supermarkets + 1; j++) {
        cost += mins[j];
    }

    free(mins);

    memcpy(new_set, set, sizeof(struct set));
    memcpy(new_set->nodes, set->nodes, set->capacity * sizeof(int));

    if (cost < *lower) {
        *lower = cost;

    }

    if (set->position < set->capacity) {
        set->nodes[set->size] = set->position;
        set->size++;
        set->position++;
        calc_custo(matrix, set, lower);

    }

    if (new_set->position < new_set->capacity) {
        new_set->nodes[new_set->size - 1] = new_set->position;
        new_set->position++;
        calc_custo(matrix, new_set, lower);
    }

}


int main (int argc, const char* argv[])
{


    int t;
    int i, j;
    int lower;
    int **matrix;

    /*allocat matrix*/

    scanf("%d", &locations);
    scanf("%d", &supermarkets);

    matrix = malloc(locations * sizeof(int*));
    for (i = 0; i < locations; i++){
        matrix[i] = malloc((supermarkets + 1) * sizeof(int));

    }

    struct set *set;
    set = malloc(sizeof(struct set));
    set->nodes = malloc(locations * sizeof(int));
    set->size = 1;
    set->position = 1;
    set->capacity = locations;
    set->nodes[0] = 0;

    for (i = 0; i < locations; i++) {
        for (j = 0; j < supermarkets + 1; j++) {
            scanf("%d", &t);
            matrix[i][j] = t;
        }
    }
    lower = INT_MAX;
    calc_custo(matrix, set, &lower);
    printf("%d\n", lower);
    return 0;
}