[算法Project] Capacited Facility Location Problem

最新推荐文章于 2018-12-31 00:09:03 发布
最新推荐文章于 2018-12-31 00:09:03 发布
阅读量527 收藏 2
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Skywalker1111/article/details/85227287
版权

这次博客的内容是关于我们算法课程的期末project：Capacited Facility Location Problem。我使用的是python语言求解。这道题乍一看像是一个线性规划问题，但最终我还是选择了贪心算法以及模拟退火算法。源代码即各种数据可见：github项目地址

文章目录

一、问题描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、问题分析

首先，我们看看这个问题的约束条件以及目标函数。目标函数肯定是求总的opencost以及assigncost的最小值，而约束则是每个factory最终存放的所有customer的demand之和不能超过它自身capacity。
这样一来，我们首先可以定义一些全局变量了。

COST = 0 #目标函数
FACNUM = 0 #工厂数量
CUSNUM = 0 #顾客数量
CAPACITY = [] #理论最大值
LOAD = [] #实际装载量
OPENCOST = [] #每个fac的打开开销
STATUS = [] #工厂状态，打开为1，关闭为0
DEMAND = [] #每个顾客的需求
ASSIGNCOST = [] #每个工厂对于每个人存放其需求的开销
ASSIGN = [] #顾客将其需求存放在哪些工厂

然后，文件读取函数如下：

def readFile(filePath):
    global COST, FACNUM, CUSNUM, CAPACITY, LOAD, OPENCOST, DEMAND, ASSIGNCOST, STATUS, ASSIGN
    #清空
    COST = 0
    FACNUM = 0
    CUSNUM = 0
    CAPACITY = []
    OPENCOST = []
    DEMAND = []
    ASSIGNCOST = []

    fopen = open('Instances/' + filePath)
    line = fopen.readline().split()
    FACNUM = int(line[0])
    CUSNUM = int(line[1])
    STATUS = [0] * FACNUM
    ASSIGN = [0] * CUSNUM
    LOAD = [0] * FACNUM
    for i in range(FACNUM):
        line = fopen.readline().split()
        CAPACITY.append(int(line[0]))
        OPENCOST.append(int(line[1]))
    for i in range(int(CUSNUM/10)):
        line = fopen.readline().replace('.', '').split()
        for j in range(10):
            DEMAND.append(int(line[j]))

    for i in range(FACNUM):
        eachFac = []
        for j in range(int(CUSNUM/10)):
            line = fopen.readline().replace('.', '').split()
            for k in range(10):
                eachFac.append(int(line[k]))
        ASSIGNCOST.append(eachFac)
    #print(ASSIGNCOST)
    fopen.close()

接下来，由于此问题是一个NP完全问题，无法在多项式时间内找到最优解。于是我决定先使用Greedy算法找到一个比较不错的局部最优解，然后用其结果，再进行模拟退火，争取收敛到全局最优解。

三、贪心算法

贪心算法的思路很简单，遍历每个顾客，看看他们的需求还能放进哪些未满的工厂。接着在所有候选工厂中选择费用最低的那个并放入。
核心代码如下：

    for cus in range(CUSNUM):
        availableFac = []
        for fac in range(FACNUM):
            if CAPACITY[fac] >= DEMAND[cus]:
                availableFac.append(fac)
        if len(availableFac) == 0:
            return
        index = availableFac[0]
        minCost = ASSIGNCOST[index][cus]

        for fac in availableFac:
            tempCost = ASSIGNCOST[fac][cus]

            if tempCost < minCost:
                index = fac
                minCost = tempCost

        if STATUS[index] == 0:
            STATUS[index] = 1
            COST += minCost + OPENCOST[index]
        else:
            COST += minCost
        CAPACITY[index] -= DEMAND[cus]
        ASSIGN[cus] = index

注意，这个贪心的策略可能有不同，有些人说我们不应该光看这个顾客对于哪个工厂的费用最小，还要看那个工厂是否已经打开，如果没打开我们需要加工厂的打开费用。这里我想说的是，评估函数我做过三个实验：1.tempCost = ASSIGNCOST[fac][cus] 2. tempCost = ASSIGNCOST[fac][cus] + OPENCOST[fac][cus] 3.就像之前所说的，如果工厂没打开，则按照2式计算；工厂已经打开，则是按照1式进行计算。结果是，1式的最终结果最好。仔细思索了一下，应该是工厂少顾客多的缘故，顾客一多，我们就无需考略工厂的打开费用了。
贪心算法源代码：贪心算法
对于71个例子，结果和时间如下：

fileresulttime
p194400.0
p281260.0
p3101260.0
p4121260.0009975433349609375
p593750.0
p680610.000997304916381836
p7100610.0
p8120610.0
p990400.0
p1077260.0
p1197260.0
p12117260.0
p13120320.0
p1491800.0
p15131800.0009620189666748047
p16171800.000995635986328125
p17120320.0
p1891800.0
p19131800.0
p20171800.0009975433349609375
p21120320.0009980201721191406
p2291800.0
p23131800.0
p24171800.0
p25191970.001996278762817383
p26161310.000997304916381836
p27215310.0009965896606445312
p28269310.000997304916381836
p29193050.0009975433349609375
p30162390.000997304916381836
p31216390.000997304916381836
p32270390.0009975433349609375
p33190550.000993490219116211
p34159890.0009989738464355469
p35213890.0009970664978027344
p36267890.001995086669921875
p37190550.000997304916381836
p38159890.0009942054748535156
p39213890.0009968280792236328
p40267890.000997304916381836
p4172260.0
p4299570.0
p43124480.0009970664978027344
p4475850.0
p4598480.0
p46126390.0009970664978027344
p4766340.0
p4890440.0
p49124200.0009984970092773438
p50100620.0
p51113510.0
p52103640.0
p53124700.000997304916381836
p54103510.0
p55119700.0009963512420654297
p56238820.0009970664978027344
p57328820.000997304916381836
p58538820.0019948482513427734
p59391210.0009980201721191406
p60238820.000997304916381836
p61328820.0009975433349609375
p62538820.000997304916381836
p63391210.001994609832763672
p64238820.001994609832763672
p65328820.000997304916381836
p66538820.0009970664978027344
p68238820.0009965896606445312
p69328820.0009832382202148438
p70538820.0019941329956054688
p71391210.0019948482513427734

每个例子的具体结果：贪心算法测例具体结果

四、模拟退火(SA)

模拟0退火算法的步骤我就不详细说了，这个大家可以去自行百度。简而言之，对于贪心算法求出的结果，我用作了SA的初始解。邻域产生新解我使用了两种操作：1.随机选出一个工厂和顾客，把这个顾客的需求从原来的工厂放入随机选出的工厂。 2.随机选出两个顾客，把他们各自的需要放入对方的工厂。当然，这么操作可能会使某些工厂的承载超过capacity，那么就要重新选择顾客或者工厂了。
对于产生的新解，我们计算其新的cost。按照模拟退火算法，如果新解小于初始解，则更新它；否则，按照Metropolis准则判断是否接受这个解。
另外，退火的初温我选择了100，末温为1。退火速度为0.99。内层循环为100次。
模拟退火核心代码如下：

def SA():
    global COST, LOAD, ASSIGN, STATUS

    T0 = 100
    T = T0
    Tmin = 1
    alpha = 0.99
    innerIter = 100
    while T > Tmin:
        for i in range(innerIter):
            if np.random.rand() > 0.5: #选一个customo去别的fac
                randCus = np.random.randint(0, CUSNUM)
                initFacOfCus = ASSIGN[randCus]
                randFac = np.random.randint(0, FACNUM)
                while randFac == initFacOfCus:
                    randFac = np.random.randint(0, FACNUM)

                while LOAD[randFac] + DEMAND[randCus] > CAPACITY[randFac]:
                    randCus = np.random.randint(0, CUSNUM)
                    initFacOfCus = ASSIGN[randCus]
                    while randFac == initFacOfCus:
                        randFac = np.random.randint(0, FACNUM)
                dValue = ASSIGNCOST[randFac][randCus] - ASSIGNCOST[initFacOfCus][randCus]
                if dValue < 0:
                    COST += dValue
                    LOAD[randFac] += DEMAND[randCus]
                    LOAD[initFacOfCus] -= DEMAND[randCus]
                    if STATUS[randFac] == 0:
                        STATUS[randFac] = 1
                        COST += OPENCOST[randFac]
                    if LOAD[initFacOfCus] == 0:
                        STATUS[initFacOfCus] = 0
                        COST -= OPENCOST[initFacOfCus]
                    ASSIGN[randCus] = randFac
                else:
                    if np.random.rand() < np.exp(-(dValue) / T):  # 接受新解
                        COST += dValue
                        LOAD[randFac] += DEMAND[randCus]
                        LOAD[initFacOfCus] -= DEMAND[randCus]
                        if STATUS[randFac] == 0:
                            STATUS[randFac] = 1
                            COST += OPENCOST[randFac]
                        if LOAD[initFacOfCus] == 0:
                            STATUS[initFacOfCus] = 0
                            COST -= OPENCOST[initFacOfCus]
                        ASSIGN[randCus] = randFac

            else: #选两个cus对调fac
                randCus1 = 0
                randCus2 = 0
                while randCus1 == randCus2:
                    randCus1 = np.random.randint(0, CUSNUM)
                    randCus2 = np.random.randint(0, CUSNUM)
                initFac1 = ASSIGN[randCus1]
                initFac2 = ASSIGN[randCus2]

                while (LOAD[initFac1] - DEMAND[randCus1] + DEMAND[randCus2] > CAPACITY[initFac1]) or (LOAD[initFac2] - DEMAND[randCus2] + DEMAND[randCus1] > CAPACITY[initFac2]) :
                    randCus1 = 0
                    randCus2 = 0
                    while randCus1 == randCus2:
                        randCus1 = np.random.randint(0, CUSNUM)
                        randCus2 = np.random.randint(0, CUSNUM)
                    initFac1 = ASSIGN[randCus1]
                    initFac2 = ASSIGN[randCus2]
                dValue = ASSIGNCOST[initFac1][randCus2] + ASSIGNCOST[initFac2][randCus1] - ASSIGNCOST[initFac1][randCus1] - ASSIGNCOST[initFac2][randCus2]
                if dValue < 0:
                    COST += dValue
                    LOAD[initFac1] += DEMAND[randCus2] - DEMAND[randCus1]
                    LOAD[initFac2] += DEMAND[randCus1] - DEMAND[randCus2]
                    ASSIGN[randCus1] = initFac2
                    ASSIGN[randCus2] = initFac1
                else:
                    if np.random.rand() < np.exp(-(dValue) / T):  # 接受新解
                        COST += dValue
                        LOAD[initFac1] += DEMAND[randCus2] - DEMAND[randCus1]
                        LOAD[initFac2] += DEMAND[randCus1] - DEMAND[randCus2]
                        ASSIGN[randCus1] = initFac2
                        ASSIGN[randCus2] = initFac1
        T = T * alpha
        #print(T, COST)
    print("The Last Cost is:", COST)

SA算法源代码：SA算法
对于71个例子，结果和时间如下：

fileresulttime
p193360.39295339584350586
p280090.40195631980895996
p3100100.3580358028411865
p4119420.39995670318603516
p591730.39095616340637207
p678910.3560817241668701
p798590.38598132133483887
p8118610.3919527530670166
p990400.26628851890563965
p1077270.27729058265686035
p1197260.2722742557525635
p12117270.26728224754333496
p13120320.2682836055755615
p1491800.2622981071472168
p15131800.2642946243286133
p16171800.26132726669311523
p17120320.26126933097839355
p1891800.2593350410461426
p19131800.2573113441467285
p20171800.2563450336456299
p21120320.25829219818115234
p2291800.260312557220459
p23131800.2623291015625
p24171800.26133203506469727
p25181640.2712745666503906
p26151410.27324533462524414
p27194270.28224611282348633
p28254750.27828550338745117
p29190610.28325653076171875
p30157130.2812771797180176
p31209330.29720377922058105
p32261480.28127551078796387
p33194740.26928067207336426
p34154330.26632142066955566
p35214250.26628828048706055
p36247290.2622997760772705
p37175640.265291690826416
p38157540.27227115631103516
p39209440.2613034248352051
p40261370.2603330612182617
p4171000.31117701530456543
p4299570.26332855224609375
p43124580.25634098052978516
p4471510.3241691589355469
p4598590.2593069076538086
p46123250.2543201446533203
p4763180.4059157371520996
p4890480.26628732681274414
p49128730.26030492782592773
p5095740.3400905132293701
p51109000.2653172016143799
p52102300.3670506477355957
p53127950.3002490997314453
p5496250.40192604064941406
p55118930.2982041835784912
p56239730.2593355178833008
p57330490.26126980781555176
p58541120.26030397415161133
p59394090.26132631301879883
p60240360.25232505798339844
p61329940.26030397415161133
p62539810.25834059715270996
p63392050.2563159465789795
p64240210.26030445098876953
p65329770.2643263339996338
p66539930.2563149929046631
p68240300.2553138732910156
p69330870.2583155632019043
p70539540.2573122978210449
p71391740.27825474739074707

每个例子的具体结果：SA算法测例具体结果

可以看到，模拟退火的例子相比于贪心算法的初始解，大部分的确有了小的进步；当然，还有些并不如贪心算法的初始解。可能这个题目的确比较适合用贪心算法把！

Skywalker1111
关注
专栏目录
Capacitated Facility Location Problem
Vilin的博客
12-22 1741
Capacitated Facility Location Problem 题目 要求 Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open. the assignment of customers to facilities. The objec...
【算法项目】Capacitated Facility Location Problem
hcm_0079的博客
12-20 887
Capacitated Facility Location Problem 问题描述 Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open the assignment of customers to facilities Note： The o...
算法project——Capacitated Facility Location Problem
diceroller的博客
12-22 761
Capacitated Facility Location Problem是一个NP难的问题，为了在有限的时间内解决这个问题，我采用了两种启发式算法来解决它。第一种是模拟退火算法，第二种是禁忌搜索算法。两种算法应该说各有千秋。 下面是Capacitated Facility Location Problem的大致内容：  Suppose there are n facilities and m...
Capacitated-Facility-Location-Problem
重新开始写博客
12-23 527
目录问题 CFLP分析基于贪心的模拟退火算法（以及局部搜索法）贪心算法代码实现基于贪心的模拟退火算法（以及局部搜索法）贪心算法结果结论参考资料 问题 CFLP Capacitated-Facility-Location-Problem Suppose there are n facilities and m customers. We wish to choose: which of the n...
四种方法求Capacitated Facility Location Problem问题
阿里武的技术博客
12-22 1868
问题详情 1. 贪心算法 1.1 算法框架 此题可以利用贪心算法来求解， 可以假设只关注顾客的cost， 当仓库满了就在下一个仓库里 具体解决方案： 将每个顾客到工厂的cost 由小到大进行排序 从第一个用户开始， 优先把此用户安排在cost小的工厂里， 如果此工厂容量已满， 则进入下一个最小cost工厂里 得到结果 1.2关键代码和注释 customer_assign = [] ...
Capacitated Facility Location Problem (Algorithm Design and Analysis Project)
c980129的博客
12-23 235
学号：16340008 目录 Question Answer 算法①：模拟退火算法  算法②：贪心算法  Comments Reference Question: Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open the as...
Project:Capacitated Facility Location Problem：（一）贪心算法
weixin_43142208的博客
12-25 231
Capacitated Facility Location Problem Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open the assignment of customers to facilities The objective is t...
算法概论 project | Capacitated Facility Location Problem —— 贪心算法、模拟退火、禁忌搜索
⊳ideal world⊲~ヽ(ﾟ︺ﾟ)Hi
12-22 596
题目描述 Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open the assignment of customers to facilities The objective is to minimize the sum of the openin...
Capacitated Facility Location Problem贪心算法实现
huang_wx的博客
12-30 257
问题描述 给定Ñ个工厂和米个顾客，开工厂需要一定的费用，一个工厂有一定的容量限制，每个顾客也有一定的需求，而每个顾客要选取某个工厂也需要一定的分配费用，现在要求找出一个分配方案，把顾客分配给不同的工厂，然后在可以满足所有顾客需求的前提下让所有的花费（开工厂的花费和分配的花费）最小。 问题分析： 解决思路 设集合I = {1，...，m}是所有设施 集合J = {1，...，n}是...
Facility Location:Concepts,Models,Algorithms and Case Studies
07-14
介绍Facility Location相关算法的综述性的经典文献，推荐研究P-Median和P-Center的同僚们阅读。
算法project实验报告
大葱敏的博客
12-23 1736
中山大学数据科学与计算机学院本科生实验报告 （2018年秋季学期） 课程名称 算法设计与分析 任课老师 张子臻 年级 2016级 专业（方向） 计算机应用 学号 16340030 姓名 陈斯敏 电话 15917173057 Email 2540740154@qq.com 开始日期 2018.12.18 完成日期 2018.12.22 实验问题描述 Capacita...
期末项目：Capacitated Facility Location Problem
L_Realoo的博客
12-31 300
题目 代码 import random import math import datetime import os import time INSTANCE_NUMBER = 71 LOOP_LENGTH = 1000 MAX_TEMPERATURE = 100 MIN_TEMPERATURE = 0.5 ATTENUATION_QUOTIENT = 0.9 MAX_NUM = 10000...
算法设计与分析项目——Capacitated Facility Location Problem
xun6838的博客
12-22 595
算法设计与分析项目——Capacitated Facility Location Problem 目录 算法设计与分析项目——Capacitated Facility Location Problem 问题详情 问题建模 算法设计 贪心算法 模拟退火算法 数据结构 代码实现 数据类Data： 贪心算法类Greedy： 模拟退火算法类Sa： 程序入口类main： 结果展示...
[算法期末项目] Capacitated Facility Location Problem
Mrfive555的博客
12-23 464
题目 给定m个工厂和n个用户,每个用户有一定的需求,并将需要被指定(assign)给某一个工厂,但工厂的承载量时有限的,被指定给某一个工厂的用户的需求总和不能超过工厂的容量(capacity).工厂的开启和用户的指定都有花费.现在我们设计一个工厂开启和用户分配的方案,需要最小化工厂开启和用户分配的花费. 思路 算法框架 这题是一个组合优化问题,在不超过工厂容量的情况下,每一个用户都可以分配到不同的...
算法设计与分析project（Capacitated Facility Location Problem）
ousuixin的博客
12-22 637
github项目 该project项目的： （1）71个测例 （2）源代码 （3）71个测例的计算结果存储文件（包括 分配方案总花费-运行时间表 和 每个测例的具体分配方案 ） 都能在我的github上获取 问题描述 这是有容量限制的工厂选址问题： （1）我们需要从待选的n个工厂中选择k个工厂来开放给用户使用 （2）我们需要将N个用户分配到k个开放的工厂 （3）要求分配到某个工厂的全部用户的需求...
Capacitated Facility Location Problem容量有限设施选址问题
Runner1st的博客
12-21 2018
Capacitated Facility Location Problem 问题如下 给出所有工厂的容量和开工厂的成本，所有客户的需求，以及客户分配给某个工厂的的分配成本，要求解的问题是：找出一个分配方案，使得总成本最低。 算法思路 思路一：贪心 容易想到的是，从每个用户的角度出发，要使得总成本最小的话，则可以每个用户选择设施的时候都贪心选择一个成本最低的设施。一开始我想的是所有设施都先不开...
Capacitated Facility Location Problem-蚁群算法-遗传算法-js实现
keyj1996的博客
12-20 615
Capacitated Facility Location Problem-蚁群算法-遗传算法-js实现问题描述：report代码样例结果 问题描述： Suppose there are n facilities and m customers. We wish to choose: which of the n facilities to open the assignment of cus...
facility location problem
最新发布
03-16
设施选址问题是指在给定的区域内，确定最佳的设施位置...这个问题通常涉及到多个因素，如设施的成本、服务范围、交通便利性等，需要通过数学模型和优化算法来解决。该问题在物流、运输、城市规划等领域中有广泛的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值