(流水车间调度 FSSP) NEH算法(优化后)c++源代码

已于 2022-08-09 14:39:07 修改
阅读量1.5k 收藏 18
点赞数 2
分类专栏： 车间调度 文章标签： c++ 启发式算法
于 2022-08-04 14:17:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44938712/article/details/126158106
版权

    Taillard等将对NEH启发式算法进行了改进，将时间复杂度从 O(mn^3) 降至了O(mn^2) ，详细原理见我的上一篇文章：

    (22条消息) (流水车间调度 FSSP) NEH启发式算法改进 (时间复杂度从 O(mn^3) 降至 O(mn^2) )_JC.223的博客-CSDN博客

    对Taillard提出的改进NEH算法进行了复现，c++源代码如下：

    NEH.h：

#pragma once
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

class NEH
{
private:
	int n; //作业数量
	int m; //机器数量
	vector<pair<int, double>> sumPcsTime; //作业根据总加工时间降序排列，int为作业，double为总加工时间
	vector<int> res; //NEH算法求解的调度结果
	double makespan = 0; //NEH算法调度结果对应的最大完工时间

	//vector<vector<double>> e; //NEH中的e矩阵，e[i][j]为第i个作业在第j台机器上的完成时间
	//vector<vector<double>> q; //NEH中的q矩阵，q[i][j]为第i个作业在第j台机器上开始的时间到所有操作结束的时间
	//vector<vector<double>> f; //NEH中的f矩阵，f[i][j]为插入第i个位置的作业k在第j台机器上的最早相对完成时间

public:
	NEH(const vector<vector<double>>& matrixT);  //输入：加工时间矩阵T （从0开始，T[0][0]即作业1在机器1上加工时间）
	vector<int> getRes(); //输出NEH算法求解结果
	double getMakespan(); //输出NEH算法调度结果对应的最大完工时间
	vector<vector<double>> calculateMakespan(vector<int> res, const vector<vector<double>>& matrixT); //直接计算最大完工时间的函数
	
    //测试用
	void printPcsTime(); //测试用，打印sumPcsTime
};

    NEH.cpp：

#include "NEH.h"
#include <numeric>
using namespace std;

NEH::NEH(const vector<vector<double>>& matrixT) {
	//初始化 作业数量n，机器数量m
	n = matrixT.size();
	m = matrixT[0].size();
	sumPcsTime.resize(n);
	//测试用，打印作业数n、机器数m、加工时间矩阵matrixT
	cout << "--NEH算法输入--" << endl;
	cout << "作业数：" << n << "  机器数：" << m << endl << "加工时间：" << endl;
	for (size_t i = 0; i < matrixT.size(); i++)
	{
		for (size_t j = 0; j < matrixT[0].size(); j++)
		{
			cout << matrixT[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;

	//NEH Step1：作业根据总加工时间降序排列
	//1.1 保存作业在各机器上的加工时间之和
	for (int i = 0; i < sumPcsTime.size(); i++) {
		sumPcsTime[i].first = i + 1;
		sumPcsTime[i].second = accumulate(matrixT[i].begin(), matrixT[i].end(), 0.0); //0 -- int；0.0 -- double
	}
	//测试用，打印排序前作业顺序以及对应的总加工时间
	cout << "NEH Step1 -- 作业根据总加工时间降序排列" << endl;
	cout << "排序前：" << endl;
	printPcsTime();

	//1.2 快速排序 O(nlogn)
	sort(sumPcsTime.begin(), sumPcsTime.end(), [](auto a, auto b) {
		return a.second > b.second;
		});
	//测试用，打印排序前作业顺序以及对应的总加工时间
	cout << "排序后：" << endl;
	printPcsTime();
	cout << endl;

	//NEH Step2：对排序后前两个作业进行调度
	//2.1 分别计算两种排列{sumPcsTime[0].first, sumPcsTime[1].first}、{sumPcsTime[1].first, sumPcsTime[0].first}的完工时间
	double makespan_1 = calculateMakespan(vector<int>{sumPcsTime[0].first, sumPcsTime[1].first}, matrixT)[1][m - 1];
	double makespan_2 = calculateMakespan(vector<int>{sumPcsTime[1].first, sumPcsTime[0].first}, matrixT)[1][m - 1];

	//2.2 返回完工时间更小的调度结果
	if (makespan_1 < makespan_2) {
		res.push_back(sumPcsTime[0].first);
		res.push_back(sumPcsTime[1].first);
	}
	else {
		res.push_back(sumPcsTime[1].first);
		res.push_back(sumPcsTime[0].first);
	}

	//测试用，打印两个调度结果
	cout << "NEH Step2 -- 对排序后前两个作业进行调度" << endl;
	vector<vector<double>> schedule1 = calculateMakespan(vector<int>{sumPcsTime[0].first, sumPcsTime[1].first}, matrixT);
	vector<vector<double>> schedule2 = calculateMakespan(vector<int>{sumPcsTime[1].first, sumPcsTime[0].first}, matrixT);
	cout << "第一种排列：" << sumPcsTime[0].first << ", " << sumPcsTime[1].first << endl << "对应调度矩阵：";
	for (size_t i = 0; i < schedule1.size(); i++)
	{
		for (size_t j = 0; j < schedule1[0].size(); j++)
		{
			cout << schedule1[i][j] << " ";
		}
		cout << "; ";
	}
	cout << "对应完工时间：" << schedule1[1][m - 1] << endl;
	cout << "第二种排列：" << sumPcsTime[1].first << ", " << sumPcsTime[0].first << endl << "对应调度矩阵：";
	for (size_t i = 0; i < schedule2.size(); i++)
	{
		for (size_t j = 0; j < schedule2[0].size(); j++)
		{
			cout << schedule2[i][j] << " ";
		}
		cout << "; ";
	}
	cout << "对应完工时间：" << schedule2[1][m - 1] << endl;
	cout << "NEH Step2 调度结果：" << res[0] << " " << res[1] << endl << endl;

	//测试用
	cout << "NEH Step3 -- k从3到n，计算使完工时间最小的第k个作业的最优插入位置" << endl;

	//NEH Step3：k从3到n，计算使完工时间最小的第k个作业的最优插入位置
	for (int k = 3; k <= n; k++) {
		//初始化e, q, k, Mmin, Imin；为了编程方便(对齐下标)，扩充了q和f的大小
		vector<vector<double>> e(k, vector<double>(m + 1, 0)); //NEH中的e矩阵
		vector<vector<double>> q(k + 1, vector<double>(m + 2, 0)); //NEH中的q矩阵
		vector<vector<double>> f(k + 1, vector<double>(m + 1, 0)); //NEH中的f矩阵

		//3.1 计算第i个作业在第j台机器上的最早完成时间e[i][j]
		for (int i = 1; i <= k - 1; i++) {
			for (int j = 1; j <= m; j++) {
				e[i][j] = max(e[i][j - 1], e[i - 1][j]) + matrixT[res[i - 1] - 1][j - 1];
			}
		}

		//3.2 计算第i个作业在第j台机器上开始的时间到操作结束的时间q[i][j]
		for (int i = k - 1; i >= 1; i--) {
			for (int j = m; j >= 1; j--) {
				q[i][j] = max(q[i][j + 1], q[i + 1][j]) + matrixT[res[i - 1] - 1][j - 1];
			}
		}

		//3.3 计算插入第i个位置的作业k在第j台机器上的最早相对完成时间f[i][j]
		for (int i = 1; i <= k; i++) {
			for (int j = 1; j <= m; j++) {
				f[i][j] = max(f[i][j - 1], e[i - 1][j]) + matrixT[sumPcsTime[k - 1].first - 1][j - 1];
			}
		}

		//3.4 计算在第i个位置插入作业k时，部分完成时间Mi的值，并更新Mmin、Imin
		double Mmin = DBL_MAX;  //用于记录第k个作业插入不同位置时的最小完工时间
		int Imin = 0;  //用于记录第k个作业插入取得最小完工时间时对应的插入位置
		vector<double> recordMi;  //测试用，记录Mi
		for (int i = 1; i <= k; i++) {
			double Mi = 0;
			
			//计算Mi
			for (int j = 1; j <= m; j++) {
				if (f[i][j] + q[i][j] > Mi) Mi = f[i][j] + q[i][j];				
			}

			//比较，得出最优插入位置Imin，以及对应的Mmin
			if (Mi < Mmin) {
				Mmin = Mi;
				Imin = i;
			}

			//测试用，记录Mi
			recordMi.push_back(Mi); 
		}

		//在最优位置插入作业k，更新调度结果
		res.insert(res.begin() + (Imin - 1), sumPcsTime[k - 1].first);
		if (k == n) makespan = Mmin;

		//测试用
		cout << "****插入第" << k << "个作业 ( 作业 " << sumPcsTime[k - 1].first << " )****";
		cout << endl << "作业k插入位置i的完工时间Mi：";
		for (size_t i = 0; i < recordMi.size(); i++) {
			cout << recordMi[i] << " ";
		}
		cout << endl << "最小完工时间：" << Mmin << ", 对应插入位置：" << Imin << endl << "本次调度结果：";
		for (size_t i = 0; i < res.size(); i++) {
			cout << res[i] << " ";
		}
		cout << endl << endl;
	}

	//测试用，打印最终调度结果
	cout << "NEH算法生成的调度结果：" << endl;
	for (size_t i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl << "对应最大完工时间：" << makespan << endl;
}

vector<int> NEH::getRes() {
	return res;
}

double NEH::getMakespan() {
	return makespan;
}

vector<vector<double>> NEH::calculateMakespan(vector<int> res, const vector<vector<double>>& matrixT) {
	int n = res.size(), m = matrixT[0].size();
	vector<vector<double>> schedule(n, vector<double>(m, 0));  //调度矩阵，存放各机器上的调度结果
	// 计算第1个工件：sche(J1,1) = matrixT(J1,1); sche(J1,k) = sche(J1,k-1) + matrixT(J1,k)
	schedule[0][0] = matrixT[res[0] - 1][0];
	for (int j = 1; j < m; j++)
	{
		schedule[0][j] = schedule[0][j - 1] + matrixT[res[0] - 1][j];
	}
	/* 计算第2至n个工件：sche(Ji,1) = sche(Ji-1,1) + matrixT(Ji,1); 
                         sche(Ji,k) = max{sche(Ji-1,k), sche(Ji,k-1)} + matrixT(J1,k) */
	for (int i = 1; i < n; i++)
	{
		schedule[i][0] = schedule[i - 1][0] + matrixT[res[i] - 1][0];
		for (int j = 1; j < m; j++)
		{
			schedule[i][j] = max(schedule[i - 1][j], schedule[i][j - 1]) + matrixT[res[i] - 1][j];
		}
	}
	// 最大完工时间：schedule[n - 1][m - 1]
	return schedule;
}

//测试用
void NEH::printPcsTime() {
	cout << "作业顺序：";
	for (size_t i = 0; i < sumPcsTime.size(); i++)
	{
		cout << sumPcsTime[i].first << " ";
	}
	cout << endl << "总加工时间：";
	for (size_t i = 0; i < sumPcsTime.size(); i++)
	{
		cout << sumPcsTime[i].second << " ";
	}
	cout << endl;
}

    main.cpp：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "NEH.h"
using namespace std;

//测试NEH
void testNEH() {
    
    //vector<vector<double>> MatrixT(20, vector<double>(5, 0));
    //Taillard-PFSP测试案例：ta001  已知最优解：1278
    //对应排序： { 3,17,15,8,9,6,5,14,16,7,11,13,18,19,1,4,2,10,20,12 }
    //MatrixT[0] = { 54, 79, 16, 66, 58 };
    //MatrixT[1] = { 83, 3, 89, 58, 56 };
    //MatrixT[2] = { 15, 11, 49, 31, 20 };
    //MatrixT[3] = { 71, 99, 15, 68, 85 };
    //MatrixT[4] = { 77, 56, 89, 78, 53 };
    //MatrixT[5] = { 36, 70, 45, 91, 35 };
    //MatrixT[6] = { 53, 99, 60, 13, 53 };
    //MatrixT[7] = { 38, 60, 23, 59, 41 };
    //MatrixT[8] = { 27, 5, 57, 49, 69 };
    //MatrixT[9] = { 87, 56, 64, 85, 13 };
    //MatrixT[10] = { 76, 3, 7, 85, 86 };
    //MatrixT[11] = { 91, 61, 1, 9, 72 };
    //MatrixT[12] = { 14, 73, 63, 39, 8 };
    //MatrixT[13] = { 29, 75, 41, 41, 49 };
    //MatrixT[14] = { 12 ,47 ,63 ,56 ,47 };
    //MatrixT[15] = { 77 ,14 ,47 ,40 ,87 };
    //MatrixT[16] = { 32 ,21 ,26 ,54 ,58 };
    //MatrixT[17] = { 87 ,86 ,75 ,77 ,18 };
    //MatrixT[18] = { 68 , 5 ,77 ,51 ,68 };
    //MatrixT[19] = { 94 ,77 ,40 ,31 ,28 };
    
    vector<vector<double>> MatrixT = { {19,46,65},{44,63,12},{85,56,98},{59,68,25},{87,66,53},{51,4,63} };

    NEH neh(MatrixT);
    cout << "直接计算得出的最大完工时间：" 
        << neh.calculateMakespan(neh.getRes(), MatrixT)[MatrixT.size() - 1][MatrixT[0].size() - 1] << endl;
}

int main()
{
    srand((unsigned)time(NULL));
    testNEH();

    system("pause");
}

    使用的测试案例来自：

    (19条消息) 基础NEH算法 在 流水车间调度问题（FlowShop)问题 的应用（C++）_Liablbility的博客-CSDN博客_neh算法

    测试结果：

    可以看到调度结果为{ 6, 2, 1, 3, 5, 4 }，最大完工时间为445，与上述链接一致。

    main.cpp中还包含了Taillard的一个测试案例（ta001），可自行测试。

参考文献：

[1]    TAILLARD E. Some efficient heuristic methods for the flow shop sequencing problem[J]. European Journal of Operational Research, 1990,47(1): 65-74.

[2]    Muhammad, Nawaz, and, et al. A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem[J]. Omega, 1983.

JC.223
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【优化算法】遗传算法GA求解混合流水车间调度问题（附C++代码）
infinitor的博客
05-31 4412
00 前言 各位读者大家好，好久没有介绍算法的推文了，感觉愧对了读者们热爱学习的心灵。于是，今天我们带来了一个神奇的优化算法——遗传算法！ 它的优点包括但不限于： 遗传算法对所求解的优化问题没有太多的数学要求，由于他的进化特性，搜索过程中不需要问题的内在性质，对于任意形式的目标函数和约束，无论是线性的还是非线性的，离散的还是连续的都可处理。 进化算子的遍历性（各态历经性）使得遗传算法能够...
c遗传算法的终止条件一般_【优化算法】遗传算法GA求解混合流水车间调度问题（附C++代码）...
weixin_30038009的博客
12-24 1602
00 前言各位读者大家好，好久没有介绍算法的推文了，感觉愧对了读者们热爱学习的心灵。于是，今天我们带来了一个神奇的优化算法——遗传算法！它的优点包括但不限于：遗传算法对所求解的优化问题没有太多的数学要求，由于他的进化特性，搜索过程中不需要问题的内在性质，对于任意形式的目标函数和约束，无论是线性的还是非线性的，离散的还是连续的都可处理。进化算子的遍历性(各态历经性)使得遗传算法能够非常有效地进行概...
基于NEH领域的搜索
07-22
文章基于NEH的领域搜索应用于车间调度产生初始化最优解
part1置换流水车间调度NEH算法Java程序.pdf
01-11
part1置换流水车间调度NEH算法Java程序.pdf
(流水车间调度 FSSP) NEH启发式算法改进 (时间复杂度从 O(mn^3) 降至 O(mn^2) )
weixin_44938712的博客
08-02 1968
NEH启发式算法改进，时间复杂度从 O(mn^3) 降至 O(mn^2) ，出自文献《Some efficient heuristic methods for the flow shop sequencing problem》
遗传算法解决（柔性）流水车间问题（Python）
qq_58327317的博客
12-11 2311
遗传算法解决（柔性）流水车间问题 Python代码
流水车间调度问题
热门推荐
seagullLol的博客
08-16 1万+
在[1]文中可以查阅到十六种车间调度问题模型，本文的讨论对象为多资源调度模型。该模型一般被描述为，在车间内包含M种不同的作业，N台不同的机器，每个作业有P种不同的零件需要安装。 [1]潘全科.车间调度问题研究[J].聊城大学学报(自然科学版),2004.03,17(1):10. ...
复杂车间调度问题模型
m0_65532100的博客
04-03 2432
目录 复杂壳体零件制造车间调度方法研究 基于数字孪生的复杂产品离散装配车间动态调度 基于启发式算法的阻塞流水车间调度问题 多约束阻塞流水车间调度优化方法研究 基于元启发式的分布式车间调度方法研究 具有工序顺序柔性的车间调度问题研究综述 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 复杂车间调度问题相比于传统经典车间调度问题更具有实际意义，本系列主要介绍复杂车间的建模过程，辅助以传统调度问题模型和求解方
车间调度的具体分类类型
leduoduodeai的博客
11-09 1160
流水车间调度和作业车间调度很多人在研究，也有很多将上述五种混合在一起研究的，本人正在学习柔性作业车间调度，有方向相同的同学可以私信交流。
求解流水车间调度问题的混合粒子群算法 (1).pdf
09-29
流水车间调度问题（Flow Shop Scheduling Problem，FSSP）是一种复杂的组合优化问题，目的是在流水车间中安排作业的顺序，以便最小化完成时间。由于问题的NP-hard性质，这类问题的解决方案通常需要使用启发式算法或...
The_Flow_Shop_Scheduling_Problem:用遗传算法解决流水车间调度问题
05-02
用遗传算法解决流水车间调度问题 在本作业中，您将解决文本文件“ fssp-data-3instances.txt”中给出的三个数据集的流水车间调度问题。 这些数据集中的作业数和机器数不同。 目标功能是最小化制造期，即完成由最后...
一种求解随机有限缓冲区流水线调度的混合差分进化算法
02-23
针对随机有限缓冲区流水线调度问题(Flow shop scheduling problem,FSSP),提出混合差分进化(Differential evolution,DE)算法OHTDE,用来最小化提前/拖后指标和最小化总体完成时间指标.OHTDE将DE和最优计算量分配...
统计信号处理 III实用算法开发 (英文版)+matlab代码.rar
06-03
《统计信号处理 III 实用算法开发 (英文版)》是一本深入探讨统计信号处理理论与实践的书籍，配合MATLAB代码，为读者提供了丰富的学习资源。统计信号处理是信号处理领域的一个重要分支，它主要研究如何利用概率统计...
fssp-3001-v12323.apk
06-25
fssp-3001-v12323.apk
遗传算法在生产调度中的应用
earthbingshi的博客
06-15 1142
遗传算法（Genetic Algorithm, GA）在生产调度中具有广泛的应用，因其强大的全局搜索能力和适应性，能够有效解决各种复杂的调度问题。
HFUT - 算法导论复习 - 分支界限法(Branch and Bound Method)
Laniakea的博客
12-30 891
简介 有点类似于回溯法(backtracking) 回溯法使用的是深度搜索 分支界限法用的是广度搜索 一般是用来解决最小化问题的 但是显然当遇到最大化问题时,我们转化成最小化问题即可 举例 时间安排(Job Sequencing) Jobs = {J1,J2,J3.J4} FIFO 分支限界法 (队列式分支限界法) 基本思想：按照队列先进先出 (FIFO) 原则选取下一个活结点为扩展结点。 搜索策略：一开始，根结点是唯一的活结点，根结点入队。从活结点队中取出根结点后，作为当前扩展结点。对当前扩展结点，先
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 414
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3507
【代码】背单词工具(C++)
fssp-3001-v4423(1).apk下载
01-24
您好，要下载fssp-3001-v4423(1).apk文件，您可以通过以下步骤进行下载： 1. 首先，打开您的手机或者平板电脑的浏览器。 2. 在浏览器的搜索栏中输入“fssp-3001-v4423(1).apk下载”并进行搜索。 3. 在搜索结果中，找到一个可靠的网站，确保它是一个安全的下载源。 4. 点击进入该网站，并找到“fssp-3001-v4423(1).apk”的下载链接。 5. 点击下载链接，等待文件下载完成。 6. 下载完成后，打开您的文件管理器，找到下载的apk文件并点击安装。 7. 如果您的手机设置了安全限制，可能需要在设置中打开“未知来源”的权限才可以安装这个.apk文件。 8. 安装完成后，您就可以使用这个应用了。 需要提醒的是，请尽量在官方或者可信赖的网站上下载应用，以确保您下载的文件是安全可靠的。另外，如果您不确定文件的来源或者真实性，建议您不要轻易安装，以防造成不必要的损失。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值