Capacitated Facility Location Problem-蚁群算法-遗传算法-js实现

最新推荐文章于 2021-06-14 21:39:16 发布
最新推荐文章于 2021-06-14 21:39:16 发布
阅读量598 收藏 6
点赞数
文章标签： 蚁群算法 遗传算法 js CFLP 容量设施选址问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keyj1996/article/details/85140535
版权

Capacitated Facility Location Problem-蚁群算法-遗传算法-js实现

问题描述：

  • 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 opening cost
    and the assignment cost.
  • The total demand assigned to a facility must not exceed
    its capacity.

report

在本次实践中，我分别采用了蚁群算法和遗传算法来对问题进行求解。

蚁群算法是一种用来寻找优化路径的概率型算法。它由Marco Dorigo于1992年在他的博士论文中提出，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。

遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法

算法对比图

代码


// 遗传算法

/** 染色体数量 */
let chromosomeNum = 100

/** 适应度矩阵(下标：染色体编号、值：该染色体的适应度) */
let adaptability = []
/** 自然选择的概率矩阵(下标：染色体编号、值：该染色体被选择的概率) */
let selectionProbability = []

/** 染色体复制的比例(每代中保留适应度较高的染色体直接成为下一代) */
let cp = 0.2
/** 参与交叉变异的染色体数量 */
let crossoverMutationNum = chromosomeNum * (1-cp)

/** 任务处理时间结果集([迭代次数][染色体编号]) */
// let resultData = []

/**
 * 初始化遗传算法
 * 初始化 顾客集合、处理设施集合
 * @param _facilities 设施参数
 * @param _demands 顾客的要求
 * @param _assignmentCost 顾客到指定设施的cost
 */

function startGa(_facilities, _demands, _assignmentCost) {
    facilities = _facilities.reduce((all, now) => all.concat(Number(now.split(' ').filter(n=>n)[0])), [])

    openCost = _facilities.reduce((all, now) => all.concat(Number(now.split(' ').filter(n=>n)[1])), [])

    customers= _demands.reduce((all, now) => all.concat(now.split(' ').filter(n =>n).map(n =>Number(n))), [])

    let tp =[]
    /* _assignmentCost.forEach(_assign => {
        assignment.push(_assign.split(' ').filter(n => n).map(n => Number(n)))
    }) */
    
    let nums = _assignmentCost.reduce((all, now) => all.concat(now.split(' ').filter(n =>n).map(n =>Number(n))), [])
    while (nums.length) {
        console.log(nums)
        tp.push(nums.splice(0, customerNum))
    }
    debugger
    for (let i = 0; i < customerNum; i++) {
        for (let j = 0; j < facilityNum; j++) {
            if (!assignment[i]) {
                assignment[i] = []
            }
            assignment[i][j] = tp[j][i]
        }
    }


}

// startGa(lines.slice(1, facilityNum+1), lines.slice(facilityNum+1, facilityNum+1+customerNum/10), lines.slice(facilityNum+1+customerNum/10))

/**
 * 遗传算法
 */
function ga() {
    // 迭代搜索
    gaSearch(iteratorNum, chromosomeNum)
}

/**
 * 计算 染色体适应度
 * @param chromosomeMatrix
 */
function calAdaptability(chromosomeMatrix) {
    // 计算每条染色体的cost
    adaptability = calCost_oneIt(chromosomeMatrix).map(n => 1/n)
}

/**
 * 计算自然选择概率
 * @param adaptability
 */
function calSelectionProbability(adaptability) {
    selectionProbability = []

    // 计算适应度总和
    let sumAdaptability = 0
    for (let i=0; i<chromosomeNum; i++) {
        sumAdaptability += adaptability[i]
    }

    // 计算每条染色体的选择概率
    for (let i=0; i<chromosomeNum; i++) {
        selectionProbability.push(adaptability[i] / sumAdaptability)
    }
}

/**
 * 迭代搜索
 * @param iteratorNum 迭代次数
 * @param chromosomeNum 染色体数量
 */
function gaSearch(iteratorNum, chromosomeNum) {
    // 初始化第一代染色体
    let chromosomeMatrix = createGeneration()

    // 迭代繁衍
    for (let itIndex=1; itIndex<iteratorNum; itIndex++) {
        // 计算上一代各条染色体的适应度
        calAdaptability(chromosomeMatrix)

        // 计算自然选择概率
        calSelectionProbability(adaptability)

        // 生成新一代染色体
        chromosomeMatrix = createGeneration(chromosomeMatrix)
    }
}


/**
 * 交叉生成{crossoverMutationNum}条染色体
 * @param chromosomeMatrix 上一代染色体矩阵
 */
function cross(chromosomeMatrix) {
    let newChromosomeMatrix = []
    for (let chromosomeIndex=0; chromosomeIndex<crossoverMutationNum; chromosomeIndex++) {

        // 采用轮盘赌选择父母染色体
        let chromosomeDad = chromosomeMatrix[RWS(selectionProbability)].slice(0)

        let chromosomeMom = chromosomeMatrix[RWS(selectionProbability)].slice(0)
        // 交叉
        let crossIndex = random(0, customerNum-1)
        chromosomeDad.splice(crossIndex)
        chromosomeDad = chromosomeDad.concat(chromosomeMom.slice(crossIndex))

        while (!checkIfLegal(chromosomeDad)) {
            console.log('cross')
            chromosomeDad = chromosomeMatrix[RWS(selectionProbability)].slice(0)

            chromosomeMom = chromosomeMatrix[RWS(selectionProbability)].slice(0)

            crossIndex = random(0, customerNum-1)
            chromosomeDad.splice(crossIndex)
            chromosomeDad = chromosomeDad.concat(chromosomeMom.slice(crossIndex))
        }
        newChromosomeMatrix.push(chromosomeDad)
    }
    return newChromosomeMatrix
}

/*
 *看一条染色体是否是可行解
 *@param chromosome 染色体
 */

function checkIfLegal(chromosome) {

    let usedCapacity= {}
    for (let i = 0; i < chromosome.length; i++) {
        if (!usedCapacity[chromosome[i]]) {
            usedCapacity[chromosome[i]] = customers[i]
        } else {
            usedCapacity[chromosome[i]] = Number(usedCapacity[chromosome[i]]) + Number(customers[i])
        }
    }
    for (let i of Object.keys(usedCapacity)) {
        if (usedCapacity[i] > facilities[i]) {
            return false
        }
    }
    return true
}

/**
 * 从数组中寻找最大的n个元素
 * @param array
 * @param n
 */
function maxN(array, n) {
    // 将一切数组升级成二维数组，二维数组的每一行都有两个元素构成[原一位数组的下标,值]
    let matrix = []
    for (let i=0; i<array.length; i++) {
        matrix.push([i, array[i]])
    }

    // 对二维数组排序
    for (let i=0; i<n; i++) {
        for (let j=1; j<matrix.length; j++) {
            if (matrix[j-1][1] > matrix[j][1]) {
                let temp = matrix[j-1]
                matrix[j-1] = matrix[j]
                matrix[j] = temp
            }
        }
    }

    // 取最大的n个元素
    let maxIndexArray = []
    for (let i=matrix.length-1; i>matrix.length-n-1; i--) {
        maxIndexArray.push(matrix[i][0])
    }

    return maxIndexArray
}

/**
 * 复制(复制上一代中优良的染色体)
 * @param chromosomeMatrix 上一代染色体矩阵
 * @param newChromosomeMatrix 新一代染色体矩阵
 */
function copy(chromosomeMatrix, newChromosomeMatrix) {
    // 寻找适应度最高的N条染色体的下标(N=染色体数量*复制比例)
    let chromosomeIndexArr = maxN(adaptability, chromosomeNum*cp)

    // 复制
    for (let i=0; i<chromosomeIndexArr.length; i++) {
        let chromosome = chromosomeMatrix[chromosomeIndexArr[i]]
        newChromosomeMatrix.push(chromosome)
    }
    return newChromosomeMatrix
}

/**
 * 计算所有染色体的cost
 * @param chromosomeMatrix
 */
function calCost_oneIt(chromosomeMatrix) {
    // 计算每条染色体的cost
    let costArray_oneIt = []
    for (let chromosomeIndex=0; chromosomeIndex<chromosomeNum; chromosomeIndex++) {
        let cost = 0
        let usedFacilities= {}
        for (let facilityIndex=0 ;facilityIndex<facilityNum; facilityIndex++) {
            for (let customerIndex=0; customerIndex<customerNum; customerIndex++) {
                if (chromosomeMatrix[chromosomeIndex][customerIndex] == facilityIndex) {
                    cost = Number(cost) + Number(assignment[customerIndex][facilityIndex])
                    // 已经开启的设施不再加openCost
                    if (!usedFacilities[facilityIndex]) {
                        usedFacilities[facilityIndex] = 1
                        cost = Number(cost) + Number(openCost[facilityIndex])
                    }
                }
            }
        }

        costArray_oneIt.push(cost)
    }
    resultDataGa.push(costArray_oneIt)
    return costArray_oneIt
}

/**
 * 繁衍新一代染色体
 * @param chromosomeMatrix 上一代染色体
 */
function createGeneration(chromosomeMatrix) {

    // 第一代染色体，随机生成
    if (!chromosomeMatrix) {
        let newChromosomeMatrix = []
        for (let chromosomeIndex=0; chromosomeIndex<chromosomeNum; chromosomeIndex++) {
            let chromosomeMatrix_i = []
            let usedCapacity = {}
            for (let customerIndex = 0; customerIndex < customerNum; customerIndex++) {
                let index = random(0, facilityNum-1)
                // 第一次用到这个设施时，加上open cost
                if (!usedCapacity[index]) {
                    usedCapacity[index] = customers[customerIndex]
                }
                // 不可以超过容量限制
                while (usedCapacity[index] + customers[customerIndex] > facilities[index]) {
                    console.log(398)
                    console.log(usedCapacity[index], customers[customerIndex], facilities[index])
                    index = random(0, facilityNum-1)
                }
                usedCapacity[index] = Number(usedCapacity[index]) + Number(customers[customerIndex])
                chromosomeMatrix_i.push(index)
            }
            newChromosomeMatrix.push(chromosomeMatrix_i)
        }

        // 计算当前染色体的cost
        calCost_oneIt(newChromosomeMatrix)
        return newChromosomeMatrix
    }

    // 交叉生成{crossoverMutationNum}条染色体
    let newChromosomeMatrix = cross(chromosomeMatrix)

    // 变异
    newChromosomeMatrix = mutation(newChromosomeMatrix)

    // 复制
    newChromosomeMatrix = copy(chromosomeMatrix, newChromosomeMatrix)

    // 计算当前染色体的任务处理时间
    calCost_oneIt(newChromosomeMatrix)

    return newChromosomeMatrix
}

/**
 * 轮盘赌算法
 * @param selectionProbability 概率数组(下标：元素编号、值：该元素对应的概率)
 * @returns {number} 返回概率数组中某一元素的下标
 */
function RWS(selectionProbability) {
    let sum = 0
    let rand = Math.random()
    for (let i=0; i<selectionProbability.length; i++) {
        sum += selectionProbability[i]
        if (sum >= rand) {
            return i
        }
    }
}


/**
 * 变异
 * @param newChromosomeMatrix 新一代染色体矩阵
 */
function mutation(newChromosomeMatrix) {
    // 随机找一条染色体
    let chromosomeIndex = random(0, crossoverMutationNum-1)

    // 随机找一个顾客
    let customerIndex = random(0, customerNum-1)

    // 随机找一个设施
    let facilityIndex = random(0, facilityNum-1)

    newChromosomeMatrix[chromosomeIndex][customerIndex] = facilityIndex

    while (!checkIfLegal(newChromosomeMatrix[chromosomeIndex])) {
        console.log(461)
        facilityIndex = random(0, facilityNum-1)
        newChromosomeMatrix[chromosomeIndex][customerIndex] = facilityIndex
    }

    return newChromosomeMatrix
}

/**
 * 渲染视图
 * @param resultData
 */
function drawGa(resultData) {
// 基于准备好的dom，初始化echarts实例
    let myChart = echarts.init(document.getElementById('ga'))

    // 指定图表的配置项和数据
    let option = {
        title: {
            text: '基于遗传算法的容量设施问题'
        },
        tooltip : {
            trigger: 'axis',
            showDelay : 0,
            axisPointer:{
                show: true,
                type : 'cross',
                lineStyle: {
                    type : 'dashed',
                    width : 1
                }
            },
            zlevel: 1
        },
        legend: {
            data:[]
        },
        toolbox: {
            show : true,
            feature : {
                mark : {show: true},
                dataZoom : {show: true},
                dataView : {show: true, readOnly: false},
                restore : {show: true},
                saveAsImage : {show: true}
            }
        },
        xAxis : [
            {
                type : 'value',
                scale:true,
                name: '迭代次数'
            }
        ],
        yAxis : [
            {
                type : 'value',
                scale:true,
                name: 'cost'
            }
        ],
        series : [
            {
                name:'遗传算法',
                type:'scatter',
                large: true,
                symbolSize: 3,
                data: (function () {
                    let d = []
                    for (let itIndex=0; itIndex<iteratorNum; itIndex++) {
                        for (let chromosomeIndex=0; chromosomeIndex<chromosomeNum; chromosomeIndex++) {
                            d.push([itIndex, resultDataGa[itIndex][chromosomeIndex]])
                        }
                    }
                    return d
                })()
            }
        ]
    }

    // 使用刚指定的配置项和数据显示图表。
    myChart.setOption(option)
}


// 蚁群算法
/** 蚂蚁的数量 */
let antNum = 100;


/** 信息素矩阵(记录每条路径上当前信息素含量，初始状态下均为0) */
let pheromoneMatrix = [];

/** 最大信息素的下标矩阵(存储当前信息素矩阵中每行最大信息素的下标) */
let maxPheromoneMatrix = [];

/** 一次迭代中，随机分配的蚂蚁临界编号(该临界点之前的蚂蚁采用最大信息素下标，而该临界点之后的蚂蚁采用随机分配) */
let criticalPointMatrix = [];

/** 顾客处理cost结果集([迭代次数][蚂蚁编号]) */
// let resultData = [];

/** 每次迭代信息素衰减的比例 */
let p = 0.5;

/** 每次经过，信息素增加的比例 */
let q = 2;

/**
 * 渲染视图
 * @param resultData
 */
function drawAca(resultData) {
// 基于准备好的dom，初始化echarts实例
    let myChart = echarts.init(document.getElementById('aca'));

    // 指定图表的配置项和数据
    let option = {
        title: {
            text: '基于蚁群算法的设施容量问题'
        },
        tooltip : {
            trigger: 'axis',
            showDelay : 0,
            axisPointer:{
                show: true,
                type : 'cross',
                lineStyle: {
                    type : 'dashed',
                    width : 1
                }
            },
            zlevel: 1
        },
        legend: {
            data:['传统蚁群算法']
        },
        toolbox: {
            show : true,
            feature : {
                mark : {show: true},
                dataZoom : {show: true},
                dataView : {show: true, readOnly: false},
                restore : {show: true},
                saveAsImage : {show: true}
            }
        },
        xAxis : [
            {
                type : 'value',
                scale:true,
                name: '迭代次数'
            }
        ],
        yAxis : [
            {
                type : 'value',
                scale:true,
                name: '总cost'
            }
        ],
        series : [
            {
                name:'蚁群算法',
                type:'scatter',
                large: true,
                symbolSize: 3,
                data: (function () {
                    let d = [];
                    for (let itIndex=0; itIndex<iteratorNum; itIndex++) {
                        for (let antIndex=0; antIndex<antNum; antIndex++) {
                            d.push([itIndex, resultDataAca[itIndex][antIndex]]);
                        }
                    }
                    return d;
                })()
            },

        ]
    };

    // 使用刚指定的配置项和数据显示图表。
    myChart.setOption(option);
}

/**
 * 初始化 顾客集合、处理设施集合
 * @param _facilities 设施参数
 * @param _demands 顾客的要求
 * @param _assignmentCost 顾客到指定设施的cost
 */
function startAca(_facilities, _demands, _assignmentCost) {

    // 初始化设施capacity集合

    facilities = _facilities.reduce((all, now) => all.concat(Number(now.split(' ')[0])), [])
    openCost = _facilities.reduce((all, now) => all.concat(Number(now.split(' ')[1])), [])
    customers= _demands.reduce((all, now) => all.concat(now.split(' ').filter(n => n).map(n =>Number(n))), [])

    _assignmentCost.forEach(_assign => {
    	assignment.push(_assign.split(' ').filter(n => n).map(n => Number(n)))
    })

    /* console.log(facilities, openCost, customers, assignment)
    // 执行蚁群算法
    aca();

    // 渲染视图
    draw(resultData);
    // console.log(resultData); */

}

// startGa(lines.slice(1, facilityNum+1), lines.slice(facilityNum+1, facilityNum+1+customerNum/10), lines.slice(facilityNum+1+customerNum/10))
/**
 * 初始化信息素矩阵(全为0)
 * @param customerNum 顾客数量
 * @param facilityNum 设施数量
 */
function initPheromoneMatrix(customerNum, facilityNum) {
    for (let i=0; i<customerNum; i++) {
        let pheromoneMatrix_i = [];
        for (let j=0; j<facilityNum; j++) {
            pheromoneMatrix_i.push(1);
        }
        pheromoneMatrix.push(pheromoneMatrix_i);
    }
}

/**
 * 初始化一个二维数组
 * @param n 行数
 * @param m 列数
 * @param defaultNum 默认值
 */
function initMatrix(n, m, defaultNum) {
    let matrix = [];
    for (let i=0; i<n; i++) {
        let matrix_i = [];
        for (let j=0; j<m; j++) {
            matrix_i.push(defaultNum);
        }
        matrix.push(matrix_i);
    }
    return matrix
}

/**
 * 将第customerCount个顾客分配给某一个设施处理
 * @param antCount 蚂蚁编号
 * @param customerCount 顾客编号
 * @param Object usedCapacity 已经启用的设施
 */
function assignOneCustomer(antCount, customerCount, usedCapacity) {

    // 若当前蚂蚁编号在临界点之前，则采用最大信息素的分配方式
    // 若当前蚂蚁编号在临界点之后，则采用随机分配方式

    let index = criticalPointMatrix.length && antCount <= criticalPointMatrix[customerCount] 
    			? maxPheromoneMatrix[customerCount]
    			: random(0, facilityNum-1)
    
    // 看index设施剩余容量是否还能满足这顾客
    if (!usedCapacity[index]) {
    	usedCapacity[index] = customers[customerCount]
    }

    // console.log(usedCapacity[index], customers[customerCount], facilities[index])

    while (usedCapacity[index]+customers[customerCount] > facilities[index] ) {
    	console.log(281)
    	index = random(0, facilityNum-1)
    }
    usedCapacity[index] = Number(customers[customerCount]) + Number(usedCapacity[index])
    return index
}

/**
 * 计算一次迭代中，所有蚂蚁的顾客处理cost
 * @param pathMatrix_allAnt 所有蚂蚁的路径
 */
function calCost_OneIt(pathMatrix_allAnt) {
    let cost_allAnt = []

    for (let antIndex=0; antIndex<pathMatrix_allAnt.length; antIndex++) {
        // 获取第antIndex只蚂蚁的行走路径
        let pathMatrix = pathMatrix_allAnt[antIndex]

        let cost = 0

        // 记录开门的设施
        let usedFacilities= {}
        for (let facilityIndex = 0; facilityIndex < facilityNum; facilityIndex++) {
            // 计算设施customerIndex的顾客处理cost
            for (let customerIndex = 0; customerIndex < customerNum; customerIndex++) {
            	// 计算一只蚂蚁分配的路线所有花销
                if (pathMatrix[customerIndex][facilityIndex]) {
                    cost += assignment[customerIndex][facilityIndex]
                    if (!usedFacilities[facilityIndex]) {
                    	usedFacilities[facilityIndex] = 1
                    	cost = Number(cost) + Number(openCost[facilityIndex])
                    } 
                }
            }
        }

        cost_allAnt.push(cost)
    }

    return cost_allAnt
}

/**
 * 更新信息素
 * @param pathMatrix_allAnt 本次迭代中所有蚂蚁的行走路径
 * @param pheromoneMatrix 信息素矩阵
 * @param costArray_oneIt 本次迭代的顾客处理cost的结果集
 */
function updatePheromoneMatrix(pathMatrix_allAnt, pheromoneMatrix, costArray_oneIt) {
    // 所有信息素均衰减p%
    for (let i = 0; i < customerNum; i++) {
        for (let j = 0; j < facilityNum; j++) {
            pheromoneMatrix[i][j] *= p;
        }
    }

    // 找出总cost最小的蚂蚁编号
    let mincost = Number.MAX_VALUE;
    let minIndex = -1;
    for (let antIndex = 0; antIndex < antNum; antIndex++) {
        if (costArray_oneIt[antIndex] < mincost) {
            mincost = costArray_oneIt[antIndex];
            minIndex = antIndex;
        }
    }

    // 将本次迭代中最优路径的信息素增加q%
    for (let customerIndex = 0; customerIndex < customerNum; customerIndex++) {
        for (let facilityIndex = 0; facilityIndex < facilityNum; facilityIndex++) {
            if (pathMatrix_allAnt[minIndex][customerIndex][facilityIndex] == 1) {
                pheromoneMatrix[customerIndex][facilityIndex] *= q;
            }
        }
    }


    maxPheromoneMatrix = [];
    criticalPointMatrix = [];
    for (let customerIndex = 0; customerIndex < customerNum; customerIndex++) {
        let maxPheromone = pheromoneMatrix[customerIndex][0]
        let maxIndex = 0
        let sumPheromone = pheromoneMatrix[customerIndex][0]
        let isAllSame = true

        for (let facilityIndex = 1; facilityIndex < facilityNum; facilityIndex++) {
            if (pheromoneMatrix[customerIndex][facilityIndex] > maxPheromone) {
                maxPheromone = pheromoneMatrix[customerIndex][facilityIndex]
                maxIndex = facilityIndex
            }
            if (pheromoneMatrix[customerIndex][facilityIndex] != pheromoneMatrix[customerIndex][facilityIndex-1]){
                isAllSame = false
            }
            sumPheromone += pheromoneMatrix[customerIndex][facilityIndex]
        }

        // 若本行信息素全都相等，则随机选择一个作为最大信息素
        if (isAllSame==true) {
            maxIndex = random(0, facilityNum-1)
            maxPheromone = pheromoneMatrix[customerIndex][maxIndex]
        }

        // 将本行最大信息素的下标加入maxPheromoneMatrix
        maxPheromoneMatrix.push(maxIndex)

        // 将本次迭代的蚂蚁临界编号加入criticalPointMatrix(该临界点之前的蚂蚁的顾客分配根据最大信息素原则，而该临界点之后的蚂蚁采用随机分配策略)
        criticalPointMatrix.push(Math.round(antNum * (maxPheromone/sumPheromone)))
    }
}


/**
 * 迭代搜索
 * @param iteratorNum 迭代次数
 * @param antNum 蚂蚁数量
 */

function acaSearch(iteratorNum, antNum) {
    for (let itCount=0; itCount<iteratorNum; itCount++) {

        // 本次迭代中，所有蚂蚁的路径
        let pathMatrix_allAnt = []

        for (let antCount=0; antCount<antNum; antCount++) {
        	let usedCapacity= {}
        	// console.log(antCount)
            // 第antCount只蚂蚁的分配策略(pathMatrix[i][j]表示第antCount只蚂蚁将i顾客分配给j设施处理)
            let pathMatrix_oneAnt = initMatrix(customerNum, facilityNum, 0)

            for (let cCount=0; cCount<customerNum; cCount++) {
            	// console.log(cCount)
                // 将第cCount个customer分配给第fcount个facility处理
                let fCount = assignOneCustomer(antCount, cCount, usedCapacity)
                pathMatrix_oneAnt[cCount][fCount] = 1

            }

            // 将当前蚂蚁的路径加入pathMatrix_allAnt
            pathMatrix_allAnt.push(pathMatrix_oneAnt)

        }

        // 计算 本次迭代中 所有蚂蚁 的花销
        let costArray_OneIt = calCost_OneIt(pathMatrix_allAnt)
        // 将本地迭代中 所有蚂蚁的 cost加入总结果集
        resultDataAca.push(costArray_OneIt)

        // 更新信息素
        updatePheromoneMatrix(pathMatrix_allAnt, pheromoneMatrix, costArray_OneIt)
    }
}

/**
 * 蚁群算法
 */
function aca() {
    // 初始化信息素矩阵
    initPheromoneMatrix(customerNum, facilityNum);
    // 迭代搜索
    acaSearch(iteratorNum, antNum);
}

样例结果

instances蚁群 resulttime (ms)遗传resulttime(ms)
p119372160016678238
p217317270314778228
p321441123415478232
p421599266617030231
p519611216816337340
p617155215917121272
p717467454219125260
p821287213920155277
p91944848014098288
p101951640712950281
p111882656316505233
p1220569146016903230
p132468829618173322
p141926245415937240
p152386739019658243
p162911232923100238
p172420924618957254
p182159223013945237
p192462125918640232
p202711027320089233
p212025124415620239
p222093722816458240
p232417530217608234
p242755436322115243
p2586414112168169678
p268553273361299694
p409715667775392711
p411394493911616247
p421704841413728338
p431793241015513389
p4417886120313675262
p451861254216218319
p462116136815371360
p4716224105013413266
p481833450714585327
p491847040215538377
p501835591515901269
p512221255518516386
p5222301152219970269
p532689171523231389
p5420466163217575271
p552511474020959394
p5681243119470821891
p5788284141280706876
p581086191149100460864
p5992969188385197869
p608073098370333887
p619201394281345909
p62107893972101119858
p639397495986221854
p648039695769039860
p658924897074799886
keyj1996
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Capacitated Facility Location Problem
Vilin的博客
12-22 1360
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...
蚁群算法的JS实现
08-10
蚁群算法就是模拟蚂蚁寻找食物的过程，它能够求出从原点出发，经过若干个给定的需求点，最终返回原点的最短路径。
蚁群算法js版，可以直接运行.在屏幕模拟蚁群觅食
12-17
蚁群算法js版,可以直接运行.在屏幕模拟蚁群觅食。 //============================ //系统参数初始化 //---------------------------- //生命体数量与轨迹长度 Unit=10;Path=10; //生命体速度上下限 v0=2;vM=10; //生命体加速度变化范围 Kr=0.1;Kv=0.1*(vM-v0); //生命体运动范围 x0=0;xM=document.documentElement.clientWidth; y0=0;yM=document.documentElement.clientHeight; //============================
群体智能算法之蚁群算法初探(二)
MobtgZhang的博客
04-19 796
上一篇博文中详细介绍了蚁群算法的背景、蚁群算法简介以及蚁群算法与TSP问题求解的问题。在这篇博文中笔者将对TSP问题用蚁群算法求解方法以及不同种类蚁群算法的应用。 1. 算法流程 2. 算法具体应用 3. 小结 ...
蚁群算法求最值c语言实现,蚁群算法求函数最大值
weixin_39733146的博客
05-23 427
这里使用蚁群算法求函数的最大值，函数是：f=-(x.^4+3*y.^4-0.2*cos(3*pi*x)-0.4*cos(4*pi*y)+0.6);步骤如下：初始化参数。初始化蚁群，第一代蚁群随机分布在可行域中。初始化信息素，第一代信息素采用第一代蚁群的函数值表示，函数值越大，信息素越多。状态转移，计算状态转移概率，根据状态转移概率进行局部搜索或全局搜索。约束边界。选择，根据目标...
遗传算法python（含例程代码与详解)
热门推荐
freeline的博客
10-24 3万+
遗传算法1.算法简介2.算法流程3.算法示例4.算法实现5.算法应用
各种优化算法
ausjtgn的专栏
08-05 3567
穷举法 列举所有可能,然后一个个去,得到最优的结果。如图一，需要从A点一直走到G点，才能知道，F是最高的（最优解）。这种算法得到的最优解肯定是最好的，但也是效率最低的。   穷举法虽然能得到最好的最优解，但效率是极其低下的。为了能提高效率，可以不要枚举所有的结果，只枚举结果集中的一部分，如果某个解在这部分解中是最优的，那么就把它当成最优解。显然这样有可能不能得到真正的最优解，
算法project——Capacitated Facility Location Problem
diceroller的博客
12-22 679
Capacitated Facility Location Problem是一个NP难的问题，为了在有限的时间内解决这个问题，我采用了两种启发式算法来解决它。第一种是模拟退火算法，第二种是禁忌搜索算法。两种算法应该说各有千秋。 下面是Capacitated Facility Location Problem的大致内容：  Suppose there are n facilities and m...
四种方法求Capacitated Facility Location Problem问题
阿里武的技术博客
12-22 1830
问题详情 1. 贪心算法 1.1 算法框架 此题可以利用贪心算法来求解， 可以假设只关注顾客的cost， 当仓库满了就在下一个仓库里 具体解决方案： 将每个顾客到工厂的cost 由小到大进行排序 从第一个用户开始， 优先把此用户安排在cost小的工厂里， 如果此工厂容量已满， 则进入下一个最小cost工厂里 得到结果 1.2关键代码和注释 customer_assign = [] ...
蚂蚁群算法的JS实现_JavaScript_蚁群算法_负载均衡调度
06-04
蚁群算法就是模拟蚂蚁寻找食物的过程，它能够求出从原点出发，经过若干个给定的需求点，最终返回原点的最短路径。这也就是著名的旅行商问题(Traveling Saleman Problem，TSP)。 本文使用蚁群算法来解决分布式环境下的负载均衡调度问题。 蚁群算法的应用——负载均衡调度 集群模式是目前较为常用的一种部署结构，也就是当单机处理能力无法满足业务需求，那么就增加处理节点，并由一个负载均衡器负责请求的调度。然而对于一个庞大系统而言，情况往往比较复杂。集群中节点的处理能力往往各不相同，而且不同任务的处理复杂度也不尽相同。那么负载均衡器如何进行任务分配，使得集群性能达到最优？资源利用率达到最高呢？这是一个极具挑战又很有价值的问题。
2020-5-A biased randomised algorithm for the capacitated facility location problem with soft constraints.pdf
08-16
2020-5-A biased randomised algorithm for the capacitated facility location problem with soft constraints.pdf
数学建模方法：蚁群算法
05-21
基于蚁群算法的基因联接学习遗传算法 基于细粒度模型的并行蚁群优化算法 Binary-Coding-Based Ant Colony Optimization and Its Convergence 运载火箭控制系统漏电故障诊断研究 混沌扰动启发式蚁群算法及其在边坡...
具有能力约束的车辆路径问题 CVRP java遗传算法实现
12-11
求解大规模具有能力约束的车辆路径问题(Capacitated Vehicle Routing Problem, CVRP)求解大规模具有能力约束的车辆路径问题(Capacitated Vehicle Routing Problem, CVRP)求解大规模具有能力约束的车辆路径问题...
1999-54-Efficient solution of large scale, single-source, capacitated plant location problems.pdf
08-16
1999-54-Efficient solution of large scale, single-source, capacitated plant location problems.pdf
Capacitated vehicle routing problem.pdf
11-19
Tejal Carwalo，Jerin Thankappan，Jerin Thankappan容量受限的VRP
群智能算法(遗传算法, 粒子群算法, 蚁群算法原理与实例分析)
lmx1458070445的博客
06-14 6958
解决函数极值问题(二元), 采用三种群智能算法实现, 并进行比较分析 1. 问题重述 求解函数: f(x,y)=6.452(x+0.125y)(cos⁡x−cos⁡(2y))20.8+(x−4.2)2+2(y−7)2+3.226yf(x, y)=\frac{6.452(x+0.125 y)(\cos x-\cos (2 y))^{2}}{\sqrt{0.8+(x-4.2)^{2}+2(y-7)^{2}}}+3.226 yf(x,y)=0.8+(x−4.2)2+2(y−7)2​6.452(x+0.125y.
Capacitated-Facility-Location-Problem
重新开始写博客
12-23 376
目录问题 CFLP分析基于贪心的模拟退火算法（以及局部搜索法）贪心算法代码实现基于贪心的模拟退火算法（以及局部搜索法）贪心算法结果结论参考资料 问题 CFLP Capacitated-Facility-Location-Problem Suppose there are n facilities and m customers. We wish to choose: which of the n...
generate a python script for Capacitated Vehicle Routing Problem (CVRP)
最新发布
06-05
Here is a basic implementation of CVRP in Python using ...Note that this is just a basic implementation and can be modified to suit specific requirements and constraints of individual problem instances.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值