PSO算法求解整数规划问题举例

最新推荐文章于 2024-05-25 13:34:38 发布
最新推荐文章于 2024-05-25 13:34:38 发布
阅读量5.7k 收藏 57
点赞数 7
分类专栏： 智能算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37980595/article/details/104467199
版权

2020-4-30粒子群算法已更新，有需要的同学移步“PSO算法求解（上）-基本PSO”和“PSO算法求解（下）-罚函数方法”，欢迎留言交流以及指正错误！

前言：最近在使用群智能算法求解线性规划问题的过程中，由于初次设计该方面的知识，在网络上检索了许多相关的智能算法的案例进行学习。首先选择了粒子群算法求解线性规划问题，但是网络上已有的一些资料对于非专业出身的同学来说理解较为困难，并且没有专门解决线性规划的实例，因此在这里进行一次分享。注意：代码可能啰嗦，适用于初入同学，有错误请指正。

首先，简要介绍一下粒子群算法。
粒子群算法（PSO）是一种起源于鸟群觅食行为的智能算法，其基本思想是通过整个群体中的个体之间的合作来寻找最优解。在粒子群算法中，粒子具有速度和位置两种属性，分别表示在搜索空间中表示搜索的快慢和搜索的方向。在搜索过程中，粒子在搜索空间中单独的进行搜寻，获得粒子个体的最优适应值（pbest），然后和群体当中的其他粒子进行合作比较，所有粒子的个体最优适应值中的最大值最为当前搜索过程中的全局最适应值(gbest)，并根据当前的个体最优适应值和全局最适应值来调整粒子自身的速度和位置，直至搜索过程结束。在搜索过程中，粒子更新速度和位置的式子如下：在这里插入图片描述
其中，c_1和c_2是学习因子；r_1和r_2是0和1之间的随机数；w是惯性权重。粒子群算法工作流程如下：
在这里插入图片描述
图片来源于图片来源，具体内容请转至链接处进行了解

求解线性规划案例如下：
max z=6x1+2x2+3x3+5x4
4x1+2x2+x3+3x4<=10
3x1-5x2+x3+6x4>=4
2x1+x2+x3-x4<=3
x1+2x2+4x3+5x4<=10
x1,x2,x3,x4=0 or 1

普通粒子群算法求解代码：

#include<iostream>
#include<stdlib.h>   
#include<stdio.h>
#include<fstream>
#include <string>
#include<ctime>
#include <algorithm>
#include <vector>

using namespace std;

//测试1：整数规划0-1
//max z=6x1+2x2+3x3+5x4
//	4x1+2x2+x3+3x4<=10
//	3x1-5x2+x3+6x4>=4
//	2x1+x2+x3-x4<=3
//	x1+2x2+4x3+5x4<=10
//	x[j]=0 or 1
//最优解z=14,x=(1,0,1,1)

//测试2：整数规划0 - 1
//max z=20x1+40x2+20x3+30X4
//	5x1+4x2+3x3+8x4<=18
//	x1+7x2+9x3+6x4<=22
//	8x1+10x2+2x3+10x4<=24
//	x[j]=0 or 1
//最优解z=90,x=(0,1,1,1)

//PSO参数
const int person_number = 20;//种群个体数目
const int dimension = 4;//搜索空间维度->变量数
double weight;//惯性权重
double LDW_ini = 0.9;//线性递减权值策略（LDW）
double LDW_end = 0.4;
double c1=2, c2=2;//学习因子
const int maxgen = 50;//迭代次数

double X_pos[person_number][dimension];//粒子位置变量
double V_speed[person_number][dimension];//粒子速度变量
double pbest[person_number];//粒子适应值
double max_pbest;//临时个体最优值
double gbest;//粒子最优值
double gbest_temp;//临时全局最优值--->更新历史值时使用
double gbest_temp_2;//临时全局最优值--->约束判断中使用
int gbest_index=0;//迭代过程中全局最优时的粒子位置
int gbest_X[dimension] = { 0 };//记录相应的X取值

//数据记录
double iter_arr[maxgen];//记录迭代次数
double gbest_arr[maxgen];//记录迭代过程中的最优值

//目标约束
const int const_num = 4;//约束数量
double C[dimension] = { 6,2,3,5 };
double A[const_num][dimension] = { {4,2,1,3},{3,-5,1,6},{2,1,1,-1},{1,2,4,5} };
double B[const_num] = { 10,4,3,10 };
//const int const_num = 3;//约束数量
//double C[dimension] = { 20,40,20,30 };
//double A[const_num][dimension] = { {5,4,3,8},{1,7,9,6},{8,10,2,10} };
//double B[const_num] = { 18,22,24 };

//目标函数
double Fitness(int pers, int dim) {//输入参数->粒子数，维数
	double fit = 0;
	for (int j = 0; j < dim; j++) {
		fit = fit + C[j] * X_pos[pers][j];
	}
	return fit;
}

//约束条件
double Constraint(int dim,int index ) {//维数，max_pbest所在粒子位置
	float constraint[const_num] = { 0 };
	gbest_temp_2 = 0;
	for (int i = 0; i < const_num; i++) {
		for (int j = 0; j < dim; j++) {
			constraint[i] = constraint[i] + A[i][j] * X_pos[index][j];
		}
	}
	if (constraint[0] <= B[0] && constraint[1] >= B[1] && constraint[2] <= B[2] && constraint[3] <= B[3]) {
	//if (constraint[0] <= B[0] && constraint[1] <= B[1] && constraint[2] <= B[2]) {
		if (max_pbest > gbest_temp_2) {//更新历史最优值
			gbest_temp_2 = max_pbest;
		}
		else {
			gbest_temp_2 = gbest_temp_2;
		}
	}
	return gbest_temp_2;
}

//权重设置
double Weight(int ITER) {
	double pso_weight = 0;
	//惯性权重
	//weight = 0.8;
	//权重计算-2
	pso_weight = ((LDW_ini - LDW_end)*(maxgen - ITER) / maxgen) + LDW_end;
	return pso_weight;
}

//初始化
void initial() {	
	for (int i = 0; i < person_number;i++) {
		for (int j = 0; j < dimension; j++) {
			X_pos[i][j] = (double)(rand() % 2);//0or1
			//V_speed[i][j] = rand() % 2;//0or1
			V_speed[i][j] = rand() % (9 + 1) / (float)(9 + 1);//0-1
		}
	}
	//初始化个体极值
	for (int i = 0; i < person_number; i++) {
		pbest[i] = Fitness(i,dimension);
	}
	//初始化全局极值---->判断是否满足约束，否则gbest=0;
	max_pbest = 0;
	for (int i = 0; i < person_number; i++) {
		if (pbest[i] > max_pbest) {
			max_pbest = pbest[i];
			gbest_index = i;
		}
		else {
			max_pbest = max_pbest;
			gbest_index = gbest_index;
		}
	}
	gbest = Constraint(dimension, gbest_index);
}

void pso() {
	int iter = 0;
	srand(time(NULL));
	while (iter<maxgen) {
		//惯性权重
		 //weight = 0.8;
		//权重计算
		weight=Weight(iter);

		//更新速度和位置
		for (int i = 0; i < person_number;i++) {
			for (int j = 0; j < dimension;j++) {
				float r_rand[2];
				for (int k = 0; k < 2;k++) {
					r_rand[k]= rand() % (9 + 1) / (float)(9 + 1);
				}
				V_speed[i][j] = weight * V_speed[i][j] + c1 * r_rand[0]*(pbest[i]-X_pos[i][j]) + c2 * r_rand[0] * (gbest - X_pos[i][j]);	
				if (V_speed[i][j] < 0 || V_speed[i][j] > 1)V_speed[i][j] = rand() % (9 + 1) / (float)(9 + 1);

				X_pos[i][j] = X_pos[i][j] + V_speed[i][j];
				if (X_pos[i][j] !=0 || X_pos[i][j] != 1)X_pos[i][j] = (double)(rand() % 2); 

			}	
		}
		
		//更新个体最优值
		for (int i = 0; i < person_number; i++) {	
			pbest[i] = Fitness(i,dimension);
		}
		
		max_pbest = 0;//临时个体最优值
		for (int i = 0; i < person_number; i++) {
			if (pbest[i] > max_pbest) {
				max_pbest = pbest[i];
				gbest_index= i;
			}
			else {
				max_pbest = max_pbest;
				gbest_index = gbest_index;
			}
		}

		//约束条件判断
		gbest_temp = Constraint(dimension, gbest_index);

		//更新历史最优值
		if (gbest_temp > gbest) {
			gbest = gbest_temp;
			for (int j = 0; j < dimension; j++) {
				gbest_X[j] = X_pos[gbest_index][j];
			}
		}
		else {
			gbest = gbest;
			for (int j = 0; j < dimension; j++) {
				gbest_X[j] = gbest_X[j];
			}
		}
		iter_arr[iter] = iter;
		gbest_arr[iter] = gbest;
		iter++;
	}
}

int main() {
	initial();
	pso();
	pso_out();
	cout << "gbest=" << gbest << endl;
	cout << "X" << endl;
	for (int j = 0; j < dimension; j++) {
		cout << gbest_X[j] << " "; 
		}
	system("pause");
	return 0;
}

自适应权重粒子群算法求解代码：

#include<iostream>
#include<stdlib.h>   
#include<stdio.h>
#include<fstream>
#include <string>
#include<ctime>
#include <algorithm>
#include <vector>

using namespace std;

//测试1：整数规划0-1
//max z=6x1+2x2+3x3+5x4
//	4x1+2x2+x3+3x4<=10
//	3x1-5x2+x3+6x4>=4
//	2x1+x2+x3-x4<=3
//	x1+2x2+4x3+5x4<=10
//	x[j]=0 or 1
//最优解z=14,x=(1,0,1,1)

//测试2：整数规划0 - 1
//max z=20x1+40x2+20x3+30X4
//	5x1+4x2+3x3+8x4<=18
//	x1+7x2+9x3+6x4<=22
//	8x1+10x2+2x3+10x4<=24
//	x[j]=0 or 1
//最优解z=90,x=(0,1,1,1)

//PSO参数
const int person_number = 20;//种群个体数目
const int dimension = 4;//搜索空间维度->变量数
double weight;//惯性权重
double LDW_ini = 0.9;//线性递减权值策略（LDW）
double LDW_end = 0.4;
double c1=2, c2=2;//学习因子
const int maxgen = 50;//迭代次数

double X_pos[person_number][dimension];//粒子位置变量
double V_speed[person_number][dimension];//粒子速度变量
double pbest[person_number];//粒子适应值
double max_pbest;//临时个体最优值
double gbest;//粒子最优值
double gbest_temp;//临时全局最优值--->更新历史值时使用
double gbest_temp_2;//临时全局最优值--->约束判断中使用
int gbest_index=0;//迭代过程中全局最优时的粒子位置
int gbest_X[dimension] = { 0 };//记录相应的X取值

//数据记录
double iter_arr[maxgen];//记录迭代次数
double gbest_arr[maxgen];//记录迭代过程中的最优值

//目标约束
const int const_num = 4;//约束数量
double C[dimension] = { 6,2,3,5 };
double A[const_num][dimension] = { {4,2,1,3},{3,-5,1,6},{2,1,1,-1},{1,2,4,5} };
double B[const_num] = { 10,4,3,10 };
//const int const_num = 3;//约束数量
//double C[dimension] = { 20,40,20,30 };
//double A[const_num][dimension] = { {5,4,3,8},{1,7,9,6},{8,10,2,10} };
//double B[const_num] = { 18,22,24 };

//目标函数
double Fitness(int pers, int dim) {//输入参数->粒子数，维数
	double fit = 0;
	for (int j = 0; j < dim; j++) {
		fit = fit + C[j] * X_pos[pers][j];
	}
	return fit;
}

//约束条件
double Constraint(int dim,int index ) {//维数，max_pbest所在粒子位置
	float constraint[const_num] = { 0 };
	gbest_temp_2 = 0;
	for (int i = 0; i < const_num; i++) {
		for (int j = 0; j < dim; j++) {
			constraint[i] = constraint[i] + A[i][j] * X_pos[index][j];
		}
	}
	if (constraint[0] <= B[0] && constraint[1] >= B[1] && constraint[2] <= B[2] && constraint[3] <= B[3]) {
	//if (constraint[0] <= B[0] && constraint[1] <= B[1] && constraint[2] <= B[2]) {
		if (max_pbest > gbest_temp_2) {//更新历史最优值
			gbest_temp_2 = max_pbest;
		}
		else {
			gbest_temp_2 = gbest_temp_2;
		}
	}
	return gbest_temp_2;
}

//权重设置
double Weight(int ITER) {
	double pso_weight = 0;
	//权重计算
	pso_weight = ((LDW_ini - LDW_end)*(maxgen - ITER) / maxgen) + LDW_end;
	return pso_weight;
}

//初始化
void initial() {	
	for (int i = 0; i < person_number;i++) {
		for (int j = 0; j < dimension; j++) {
			X_pos[i][j] = (double)(rand() % 2);//0or1
			//V_speed[i][j] = rand() % 2;//0or1
			V_speed[i][j] = rand() % (9 + 1) / (float)(9 + 1);//0-1
		}
	}
	//初始化个体极值
	for (int i = 0; i < person_number; i++) {
		pbest[i] = Fitness(i,dimension);
	}
	//初始化全局极值---->判断是否满足约束，否则gbest=0;
	max_pbest = 0;
	for (int i = 0; i < person_number; i++) {
		if (pbest[i] > max_pbest) {
			max_pbest = pbest[i];
			gbest_index = i;
		}
		else {
			max_pbest = max_pbest;
			gbest_index = gbest_index;
		}
	}
	gbest = Constraint(dimension, gbest_index);
}

void pso() {
	int iter = 0;
	srand(time(NULL));
	while (iter<maxgen) {
		//权重计算
		weight=Weight(iter);

		//更新速度和位置
		for (int i = 0; i < person_number;i++) {
			for (int j = 0; j < dimension;j++) {
				float r_rand[2];
				for (int k = 0; k < 2;k++) {
					r_rand[k]= rand() % (9 + 1) / (float)(9 + 1);
				}
				V_speed[i][j] = weight * V_speed[i][j] + c1 * r_rand[0]*(pbest[i]-X_pos[i][j]) + c2 * r_rand[0] * (gbest - X_pos[i][j]);	
				if (V_speed[i][j] < 0 || V_speed[i][j] > 1)V_speed[i][j] = rand() % (9 + 1) / (float)(9 + 1);

				X_pos[i][j] = X_pos[i][j] + V_speed[i][j];
				if (X_pos[i][j] !=0 || X_pos[i][j] != 1)X_pos[i][j] = (double)(rand() % 2); 

			}	
		}
		
		//更新个体最优值
		for (int i = 0; i < person_number; i++) {	
			pbest[i] = Fitness(i,dimension);
		}
		
		max_pbest = 0;//临时个体最优值
		for (int i = 0; i < person_number; i++) {
			if (pbest[i] > max_pbest) {
				max_pbest = pbest[i];
				gbest_index= i;
			}
			else {
				max_pbest = max_pbest;
				gbest_index = gbest_index;
			}
		}

		//约束条件判断
		gbest_temp = Constraint(dimension, gbest_index);

		//更新历史最优值
		if (gbest_temp > gbest) {
			gbest = gbest_temp;
			for (int j = 0; j < dimension; j++) {
				gbest_X[j] = X_pos[gbest_index][j];
			}
		}
		else {
			gbest = gbest;
			for (int j = 0; j < dimension; j++) {
				gbest_X[j] = gbest_X[j];
			}
		}
		iter_arr[iter] = iter;
		gbest_arr[iter] = gbest;
		iter++;
	}
}

int main() {
	initial();
	pso();
	pso_out();
	cout << "gbest=" << gbest << endl;
	cout << "X" << endl;
	for (int j = 0; j < dimension; j++) {
		cout << gbest_X[j] << " "; 
		}
	system("pause");
	return 0;
}
南音小榭
关注
  • 7
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
matlab代码_粒子群整数_粒子群算法matlab代码_混合整数规划_APSO
09-10
文件包含PSO和APSO（自适应粒子群算法）matlab代码，求解混合整数规划的matlab代码
【运筹学】整数规划 ( 整数规划示例 | 整数规划解决的核心问题 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-11 2816
一、整数规划示例、 二、整数规划解决的核心问题
Matlab中采用PSO求解整数规划0-1问题
undone99的博客
11-09 384
确定这个方向后，在csdn及github上都搜索了PSO的相关代码，发现主流的有采用01变量及罚函数两种方法，但或者缺少详细原理说明或者采用的并非matlab语言（对于电气学子matlab真的很重要！
【智能优化算法】粒子群优化算法（PSO）【附python实现代码】
最新发布
学无止境、积少成多、厚积薄发
05-25 2281
粒子群优化算法（PSO）【附python实现代码】
粒子群算法尝试解决整数规划问题（效果不好的尝试）
qq_33124895的博客
06-03 6623
1问题描述 某厂每日8小时的产量不低于1800件．为了进行质量控制，计划聘请两种不同水平的检验员．且每种检验员的日产量不高于1800件．一级检验员的标准为：速度25件/小时，正确率98%，计时工资4元/小时；二级检验员的标准为：速度15件/小时，正确率95%，计时工资3元/小时．检验员每错检一次，工厂要损失2元．为使总检验费用最省，该工厂应聘一级、二级检验员各几名？ 2 分析问题 ...
无人机均匀能耗（粒子群+0-1整数规划）
weixin_47932058的博客
04-14 2348
文章目录@[TOC](文章目录)一、问题描述分析1.1应用问题描述1.2问题描述分析二、总体方案设计2.1粒子群算法设计2.1.1粒子群迭代流程2.1.2设计粒子群适应速函数2.1.3粒子群粒子更新规则2.2 0-1整数规划设计2.3 实现流程三、仿真结果3.1仿真参数初始化3.2仿真一:编队中心不变3.3仿真二：编队中心可变（以平均距离和最长距离为适应度函数）3.4仿真三：编队中心可变（以平均距离和标准差为适应度函数）四、结论与未来工作 一、问题描述分析 1.1应用问题描述 现有匈牙利算法在多无人机编.
多元分类SVM（多类别SVM）程序使用说明
qy20115549的博客
08-21 1万+
目录操作流程 程序的数据格式 matlab程序操作流程首先，在这个网站上下载libsvm程序包http://download.csdn.net/detail/qy20115549/9608108。下载之后，将其放到某一目录下，点击菜单栏中的设置路径（set path）。将该文件夹添加到path中，这样其他文件夹，便可直接调用了。程序的数据格式如下程序中，测试集为testData，其中包含test t
粒子群算法
热门推荐
qq_52117903的博客
07-16 5万+
粒子群算法，其全称为粒子群优化算法(ParticleSwarmOptimization,PSO)。它是通过模拟鸟群觅食行为而发展起来的一种基于群体协作的搜索算法。粒子群算法属于启发式算法也叫智能优化算法，其基本思想在于通过群体中个体之间的协作和信息共享来寻找最优解。1995年，美国学者Kennedy和Eberhart共同提出了粒子群算法，其基本思想源于对鸟类群体行为进行建模与仿真的研究结果的启发。粒子优化问题的候选解位置候选解所在的位置速度候选解移动的速度适应度。...
PSO算法求解CVRP“车辆路径问题
04-09
PSO算法求解CVRP“车辆路径问题”，这是其matlab代码 PSO算法求解CVRP“车辆路径问题”，这是其matlab代码
PSO算法求解作业车间调度问题
11-25
采用粒子群优化算法求解典型的NP-Hard问题——作业车间调度问题，优化目标为平均流动时间，希望对大家研究该问题有帮助！
动态规划问题使用GA和PSO算法求解10个城市TSP问题（动态规划）
07-07
动态规划问题使用GA和PSO算法求解10个城市TSP问题（动态规划）
应用GA和PSO算法求解10城市TSP问题
09-22
应用GA和PSO算法求解10城市TSP问题
PSO算法求解函数的根.rar
05-02
PSO算法求解函数的根
群智能算法(遗传算法, 粒子群算法, 蚁群算法原理与实例分析)
lmx1458070445的博客
06-14 7197
解决函数极值问题(二元), 采用三种群智能算法实现, 并进行比较分析 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.
粒子群算法求解带约束优化问题 源码实现
总裁余（余登武）博客
03-30 1万+
粒子群算法求解带约束优化问题 源码实现 python实现。带你体验下粒子群算法是如何求解带等式约束、不等式约束、上下限约束的问题。
数学建模：整数规划示例模型 (Python 求解)
Charles Leclerc's blog
04-30 5734
例 1 : 选课策略模型1. 为了选修课程门数最少, 应学习哪些课程?建立 0-1 规划模型Python 求解2. 选修课程最少时, 为了学分尽量多, 应学习哪些课程?例 2 : 装箱问题模型 1 : 体积上多装建立整数规划模型Python 求解模型 2 : 重量上多装 对于限制全部或部分决策变量取离散非负整数值的线性规划, 称之整数线性规划, 简称整数规划. 整数规划的一种特殊情形是 0−10-10−1 整数规划, 它的决策变量仅限于 0 或 1, 简称 0−10-10−1 规划. 用 Python
Python优化算法03——粒子群算法
weixin_46277779的博客
09-12 1844
Python实现粒子群算法解决约束规划问题，非线性约束问题
基于粒子群算法的线性规划问题求解matlab程序
weixin_47365903的博客
11-28 1325
（3）对每个粒子，用它的适应度值 fit[i]fit[i] 和个体极值 pbest(i)pbest(i) 比较。如果 fit[i]>pbest(i)fit[i]>pbest(i)，则用 fit[i]fit[i]替换掉 pbest(i)pbest(i)。（4）对每个粒子，用它的适应度值 fit[i]fit[i] 和全局极值 gbestgbest 比较。如果 fit[i]>gbestfit[i]>gbest 则用 fit[i]fit[i]替换掉 gbestgbest。否则返回步骤（2）。
PSO优化算法求解TSP问题有什么优点
06-09
PSO算法是一种基于群体智能的优化算法，通过模拟鸟群或鱼群等生物的集体行为，来寻找最优解。PSO算法在求解TSP问题时具有以下优点： 1. 全局搜索能力强：PSO算法能够全局搜索解空间，找到全局最优解，避免了陷入局部最优解的问题。 2. 收敛速度快：PSO算法具有较快的收敛速度，能够在较短的时间内找到较优解。 3. 算法简单易实现：PSO算法相对于其他优化算法来说，具有较简单的算法结构，易于实现。 4. 鲁棒性强：PSO算法对初始种群的选择不敏感，能够在不同的初始种群下寻找到最优解。 综上所述，PSO算法在求解TSP问题时具有较强的全局搜索能力、较快的收敛速度、简单易实现以及鲁棒性强等优点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南音小榭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值