JSP（机器调度问题）使用java调用cplex求解

已于 2022-07-29 16:01:06 修改
阅读量743 收藏 9
点赞数 4
文章标签： java servlet 开发语言
于 2022-07-25 09:52:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whq002/article/details/125968109
版权

机器调度问题（JSP问题）描述为：在给定每个工件的加工流程、每个工件使用机器的序列及每个工件每道工序的加工时间确定的情况下，安排工件的加工顺序，使得待加工的工件在机器上进行加工的最大完工时刻最小。

接着上次的JSP模型（ 机器调度(JSP)问题数学模型_上善若水阳阳的博客-CSDN博客），我们给出一个具体的问题，并用java调用cplex进行求解。

我们给出各个工件加工的流程和各个工件在机器上的加工时间：

工件1工作流程：1,2,3         t_{1}^{1}=10,t_{2}^{1}=8,t_{3}^{1}=4

工件2工作流程：2,1,4,3      t_{2}^{2}=8,t_{1}^{2}=3,t_{4}^{2}=5,t_{3}^{2}=6

工件3工作流程：1,2,4         t_{1}^{3}=4,t_{2}^{3}=7,t_{4}^{3}=3

 现在使用java调用cplex进行求解。

1.首先定义cplex环境变量：

IloCplex cplex1 = new IloCplex();

2.紧接着我们定义问题的决策变量。我们定义两类决策变量，一类是每个工件每道工序的最大完工时刻，另一类是使用同一台机器加工不同工件的先后顺序。

每个工件每道工序的最大完工时刻：对于第i个工件被第k台机器加工，我们定义决策变量为c_{ik}。

//定义决策变量
			 IloNumVar c11 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c21 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c31 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c22 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c12 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c42 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c32 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c13 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c23 = cplex1.numVar(0, Double.MAX_VALUE);
			 IloNumVar c43 = cplex1.numVar(0, Double.MAX_VALUE);

同一台机器加工不同工件的先后顺序：第k台机器加工第i和第j个工件，如果机器k先加工第i个工件，紧接着加工第j个工件，我们定义决策变量为x_{ijk}。为方便数学模型建立，同时对每一台机器虚拟一个初始工件0和最后加工的工件M。

//定义决策变量
			 IloNumVar x011 = cplex1.intVar(0, 1);
			 IloNumVar x021 = cplex1.intVar(0, 1);
			 IloNumVar x031 = cplex1.intVar(0, 1);
			 IloNumVar x121 = cplex1.intVar(0, 1);
			 IloNumVar x131 = cplex1.intVar(0, 1);
			 IloNumVar x1M1 = cplex1.intVar(0, 1);
			 IloNumVar x211 = cplex1.intVar(0, 1);
			 IloNumVar x231 = cplex1.intVar(0, 1);
			 IloNumVar x2M1 = cplex1.intVar(0, 1);
			 IloNumVar x311 = cplex1.intVar(0, 1);
			 IloNumVar x321 = cplex1.intVar(0, 1);
			 IloNumVar x3M1 = cplex1.intVar(0, 1);
			 
			 
			 IloNumVar x012 = cplex1.intVar(0, 1);
			 IloNumVar x022 = cplex1.intVar(0, 1);
			 IloNumVar x032 = cplex1.intVar(0, 1);
			 IloNumVar x122 = cplex1.intVar(0, 1);
			 IloNumVar x132 = cplex1.intVar(0, 1);
			 IloNumVar x1M2 = cplex1.intVar(0, 1);
			 IloNumVar x212 = cplex1.intVar(0, 1);
			 IloNumVar x232 = cplex1.intVar(0, 1);
			 IloNumVar x2M2 = cplex1.intVar(0, 1);
			 IloNumVar x312 = cplex1.intVar(0, 1);
			 IloNumVar x322 = cplex1.intVar(0, 1);
			 IloNumVar x3M2 = cplex1.intVar(0, 1);
			 
			 IloNumVar x013 = cplex1.intVar(0, 1);
			 IloNumVar x023 = cplex1.intVar(0, 1);
			 IloNumVar x123 = cplex1.intVar(0, 1);
			 IloNumVar x1M3 = cplex1.intVar(0, 1);
			 IloNumVar x213 = cplex1.intVar(0, 1);
			 IloNumVar x2M3 = cplex1.intVar(0, 1);
			 
			 IloNumVar x024 = cplex1.intVar(0, 1);
			 IloNumVar x034 = cplex1.intVar(0, 1);
			 IloNumVar x234 = cplex1.intVar(0, 1);
			 IloNumVar x2M4 = cplex1.intVar(0, 1);
			 IloNumVar x324 = cplex1.intVar(0, 1);
			 IloNumVar x3M4 = cplex1.intVar(0, 1);

3.定义目标函数

这里我们考虑最小化最大完工时间，考虑将每一个工件的最后一道工序的完工时间最小化，在本问题中即最小化c31,c32,c43中的最大值，minimize max{c31,c32,c43}。

//定义目标函数
			 
			 IloNumExpr obj = cplex1.numExpr();
			 IloNumExpr c = cplex1.intVar(0, (int) Double.MAX_VALUE);

			 cplex1.addGe(c,c31);
			 cplex1.addGe(c,c32);
			 cplex1.addGe(c,c43);
			
			 obj = cplex1.sum(obj,cplex1.prod(c, 1));
	         cplex1.addMinimize(obj);

4.约束条件

首先定义约束：

//约束条件
	         IloNumExpr cs1 = cplex1.numExpr();
	         IloNumExpr cs2 = cplex1.numExpr();
	         IloNumExpr cs3 = cplex1.numExpr();
	         IloNumExpr cs4 = cplex1.numExpr();
	         IloNumExpr cs5 = cplex1.numExpr();
	         IloNumExpr cs6 = cplex1.numExpr();
	         IloNumExpr cs7 = cplex1.numExpr();
	         IloNumExpr cs8 = cplex1.numExpr();
	         IloNumExpr cs9 = cplex1.numExpr();
	         IloNumExpr cs10 = cplex1.numExpr();
	         IloNumExpr cs11= cplex1.numExpr();
	         IloNumExpr cs12 = cplex1.numExpr();
	         IloNumExpr cs13 = cplex1.numExpr();
	         IloNumExpr cs14 = cplex1.numExpr();
	         IloNumExpr cs15 = cplex1.numExpr();
	         IloNumExpr cs16 = cplex1.numExpr();
	         IloNumExpr cs17 = cplex1.numExpr();
	         IloNumExpr cs18 = cplex1.numExpr();
	         IloNumExpr cs19 = cplex1.numExpr();
	         IloNumExpr cs20 = cplex1.numExpr();
	         IloNumExpr cs21 = cplex1.numExpr();
	         IloNumExpr cs22 = cplex1.numExpr();
	         IloNumExpr cs23 = cplex1.numExpr();
	         IloNumExpr cs24 = cplex1.numExpr();
	         IloNumExpr cs25 = cplex1.numExpr();
	         IloNumExpr cs26 = cplex1.numExpr();
	         IloNumExpr cs27 = cplex1.numExpr();
	         IloNumExpr cs28 = cplex1.numExpr();
	         IloNumExpr cs29 = cplex1.numExpr();
	         IloNumExpr cs30 = cplex1.numExpr();
	         IloNumExpr cs31 = cplex1.numExpr();
	         IloNumExpr cs32 = cplex1.numExpr();
	         IloNumExpr cs33 = cplex1.numExpr();
	         IloNumExpr cs34 = cplex1.numExpr();
	         IloNumExpr cs35 = cplex1.numExpr();
	         IloNumExpr cs36 = cplex1.numExpr();
	         IloNumExpr cs37 = cplex1.numExpr();
	         IloNumExpr cs38 = cplex1.numExpr();
	         IloNumExpr cs39 = cplex1.numExpr();
	         IloNumExpr cs40 = cplex1.numExpr();
	         IloNumExpr cs41 = cplex1.numExpr();
	         IloNumExpr cs42 = cplex1.numExpr();
	         IloNumExpr cs43 = cplex1.numExpr();
	         IloNumExpr cs44 = cplex1.numExpr();
	         IloNumExpr cs45 = cplex1.numExpr();
	         IloNumExpr cs46 = cplex1.numExpr();
	         IloNumExpr cs47 = cplex1.numExpr();
	         IloNumExpr cs48 = cplex1.numExpr();
	         IloNumExpr cs49 = cplex1.numExpr();
	         IloNumExpr cs50 = cplex1.numExpr();
	         IloNumExpr cs51 = cplex1.numExpr();
	         IloNumExpr cs52 = cplex1.numExpr();
	         IloNumExpr cs53 = cplex1.numExpr();
	         IloNumExpr cs54 = cplex1.numExpr();

流程约束条件（每一个工件第一道工序的完工时间大于等于工件第一道工序的加工时间）：

             cs1 = cplex1.sum(cs1,cplex1.prod(c11,1));
	         cs2 = cplex1.sum(cs2,cplex1.prod(c22,1));
	         cs3 = cplex1.sum(cs3,cplex1.prod(c13,1));

每一个工件的流程：

             //工件1的流程
	         cs4 = cplex1.sum(cs4,cplex1.prod(c21,1));
	         cs4 = cplex1.sum(cs4,cplex1.prod(c11,-1));
	         
	         cs5 = cplex1.sum(cs5,cplex1.prod(c31, 1));
	         cs5 = cplex1.sum(cs5,cplex1.prod(c21, -1));
	         
	         //工件2的流程
	         cs6 = cplex1.sum(cs6,cplex1.prod(c12, 1));
	         cs6 = cplex1.sum(cs6,cplex1.prod(c22, -1));
	         
	         cs7 = cplex1.sum(cs7,cplex1.prod(c42, 1));
	         cs7 = cplex1.sum(cs7,cplex1.prod(c12, -1));
	         
	         cs8 = cplex1.sum(cs8,cplex1.prod(c32, 1));
	         cs8 = cplex1.sum(cs8,cplex1.prod(c42, -1));
	         
	         //工件3的流程
	         cs9 = cplex1.sum(cs9,cplex1.prod(c23, 1));
	         cs9 = cplex1.sum(cs9,cplex1.prod(c13, -1));
	         
	         cs10 = cplex1.sum(cs10,cplex1.prod(c43, 1));
	         cs10 = cplex1.sum(cs10,cplex1.prod(c23, -1));
	         
             //备注：括号内逗号后的数字分别表示每一道工序的加工时间
	         cplex1.addGe(cs1,10);
	         cplex1.addGe(cs2,8);
	         cplex1.addGe(cs3,4);
	         cplex1.addGe(cs4,8);
	         cplex1.addGe(cs5,4);
	         cplex1.addGe(cs6,3);
	         cplex1.addGe(cs7,5);
	         cplex1.addGe(cs8,6);
	         cplex1.addGe(cs9,7);
	         cplex1.addGe(cs10,3);

同一台机器加工不同零件先后顺序的约束条件：

  • (1,1),(1,2),(1,3)构成的三角形流程
//机器加工顺序约束条件
	         //(1,1),(1,2),(1,3)构成的三角形流程

	         //虚拟的开始工件0
	         cs11 = cplex1.sum(cs11,cplex1.prod(x011,1));
	         cs11 = cplex1.sum(cs11,cplex1.prod(x021,1));
	         cs11 = cplex1.sum(cs11,cplex1.prod(x031,1));
	         cplex1.addEq(cs11,1);

	        //虚拟的结束工件M
	         cs12 = cplex1.sum(cs12,cplex1.prod(x1M1,1));
	         cs12 = cplex1.sum(cs12,cplex1.prod(x2M1,1));
	         cs12 = cplex1.sum(cs12,cplex1.prod(x3M1,1));
	         cplex1.addEq(cs12,1);
	         
             //每一个中间节点只有一个紧前工序和一个紧后工序
	         cs13 = cplex1.sum(cs13,cplex1.prod(x011,1));
	         cs13 = cplex1.sum(cs13,cplex1.prod(x211,1));
	         cs13 = cplex1.sum(cs13,cplex1.prod(x311,1));
	         cs14 = cplex1.sum(cs14,cplex1.prod(x121,1));
	         cs14 = cplex1.sum(cs14,cplex1.prod(x131,1));
	         cs14 = cplex1.sum(cs14,cplex1.prod(x1M1,1));
	         cplex1.addEq(cs13,1);
	         cplex1.addEq(cs14,1);
	         
	         cs15 = cplex1.sum(cs15,cplex1.prod(x021,1));
	         cs15 = cplex1.sum(cs15,cplex1.prod(x121,1));
	         cs15 = cplex1.sum(cs15,cplex1.prod(x321,1));
	         cs16 = cplex1.sum(cs16,cplex1.prod(x211,1));
	         cs16 = cplex1.sum(cs16,cplex1.prod(x231,1));
	         cs16 = cplex1.sum(cs16,cplex1.prod(x2M1,1));
	         cplex1.addEq(cs15,1);
	         cplex1.addEq(cs16,1);
	         
	         cs17 = cplex1.sum(cs17,cplex1.prod(x031,1));
	         cs17 = cplex1.sum(cs17,cplex1.prod(x231,1));
	         cs17 = cplex1.sum(cs17,cplex1.prod(x131,1));
	         cs18 = cplex1.sum(cs18,cplex1.prod(x311,1));
	         cs18 = cplex1.sum(cs18,cplex1.prod(x321,1));
	         cs18 = cplex1.sum(cs18,cplex1.prod(x3M1,1));
	         cplex1.addEq(cs17,1);
	         cplex1.addEq(cs18,1);
	         
             //紧前工序的完工时刻加上紧后工序的加工时间小于等于紧后工序的完工时刻
	         cs19 = cplex1.sum(cs19,cplex1.prod(c11,1));
	         cs19 = cplex1.sum(cs19,cplex1.prod(c12,-1));
	         cs19 = cplex1.sum(cs19,cplex1.prod(x121,1000));
	         cplex1.addLe(cs19,1000-3);
	         
	         cs20 = cplex1.sum(cs20,cplex1.prod(c12,1));
	         cs20 = cplex1.sum(cs20,cplex1.prod(c11,-1));
	         cs20 = cplex1.sum(cs20,cplex1.prod(x211,1000));
	         cplex1.addLe(cs20,1000-10);
	         
	         cs21 = cplex1.sum(cs21,cplex1.prod(c11,1));
	         cs21 = cplex1.sum(cs21,cplex1.prod(c13,-1));
	         cs21 = cplex1.sum(cs21,cplex1.prod(x131,1000));
	         cplex1.addLe(cs21,1000-4);
	         
	         cs22 = cplex1.sum(cs22,cplex1.prod(c13,1));
	         cs22 = cplex1.sum(cs22,cplex1.prod(c11,-1));
	         cs22 = cplex1.sum(cs22,cplex1.prod(x311,1000));
	         cplex1.addLe(cs22,1000-10);
	         
	         cs23 = cplex1.sum(cs23,cplex1.prod(c12,1));
	         cs23 = cplex1.sum(cs23,cplex1.prod(c13,-1));
	         cs23 = cplex1.sum(cs23,cplex1.prod(x231,1000));
	         cplex1.addLe(cs23,1000-4);
	         
	         cs24 = cplex1.sum(cs24,cplex1.prod(c13,1));
	         cs24 = cplex1.sum(cs24,cplex1.prod(c12,-1));
	         cs24 = cplex1.sum(cs24,cplex1.prod(x321,1000));
	         cplex1.addLe(cs24,1000-3);
  • (2,1),(2,2),(2,3)构成的三角形流程
            //(2,1),(2,2),(2,3)构成的三角形流程
	         
             //虚拟的开始工件0
	         cs25 = cplex1.sum(cs25,cplex1.prod(x012,1));
	         cs25 = cplex1.sum(cs25,cplex1.prod(x022,1));
	         cs25 = cplex1.sum(cs25,cplex1.prod(x032,1));
	         cplex1.addEq(cs25,1);
             
	         //虚拟的结束工件M
	         cs26 = cplex1.sum(cs26,cplex1.prod(x1M2,1));
	         cs26 = cplex1.sum(cs26,cplex1.prod(x2M2,1));
	         cs26 = cplex1.sum(cs26,cplex1.prod(x3M2,1));
	         cplex1.addEq(cs26,1);
	         
	         //每一个中间节点只有一个紧前工序和一个紧后工序
	         cs27 = cplex1.sum(cs27,cplex1.prod(x012,1));
	         cs27 = cplex1.sum(cs27,cplex1.prod(x212,1));
	         cs27 = cplex1.sum(cs27,cplex1.prod(x312,1));
	         cs28 = cplex1.sum(cs28,cplex1.prod(x122,1));
	         cs28 = cplex1.sum(cs28,cplex1.prod(x132,1));
	         cs28 = cplex1.sum(cs28,cplex1.prod(x1M2,1));
	         cplex1.addEq(cs27,1);
	         cplex1.addEq(cs28,1);
	         
	         cs29 = cplex1.sum(cs29,cplex1.prod(x022,1));
	         cs29 = cplex1.sum(cs29,cplex1.prod(x122,1));
	         cs29 = cplex1.sum(cs29,cplex1.prod(x322,1));
	         cs30 = cplex1.sum(cs30,cplex1.prod(x212,1));
	         cs30 = cplex1.sum(cs30,cplex1.prod(x232,1));
	         cs30 = cplex1.sum(cs30,cplex1.prod(x2M2,1));
	         cplex1.addEq(cs29,1);
	         cplex1.addEq(cs30,1);
	         
	         cs31 = cplex1.sum(cs31,cplex1.prod(x032,1));
	         cs31 = cplex1.sum(cs31,cplex1.prod(x232,1));
	         cs31 = cplex1.sum(cs31,cplex1.prod(x132,1));
	         cs32 = cplex1.sum(cs32,cplex1.prod(x312,1));
	         cs32 = cplex1.sum(cs32,cplex1.prod(x322,1));
	         cs32 = cplex1.sum(cs32,cplex1.prod(x3M2,1));
	         cplex1.addEq(cs31,1);
	         cplex1.addEq(cs32,1);
	         
             //紧前工序的完工时刻加上紧后工序的加工时间小于等于紧后工序的完工时刻
	         cs33 = cplex1.sum(cs33,cplex1.prod(c21,1));
	         cs33 = cplex1.sum(cs33,cplex1.prod(c22,-1));
	         cs33 = cplex1.sum(cs33,cplex1.prod(x122,1000));
	         cplex1.addLe(cs33,1000-8);
	         
	         cs34 = cplex1.sum(cs34,cplex1.prod(c22,1));
	         cs34 = cplex1.sum(cs34,cplex1.prod(c21,-1));
	         cs34 = cplex1.sum(cs34,cplex1.prod(x212,1000));
	         cplex1.addLe(cs34,1000-8);
	         
	         cs35 = cplex1.sum(cs35,cplex1.prod(c21,1));
	         cs35 = cplex1.sum(cs35,cplex1.prod(c23,-1));
	         cs35 = cplex1.sum(cs35,cplex1.prod(x132,1000));
	         cplex1.addLe(cs35,1000-7);
	         
	         cs36 = cplex1.sum(cs36,cplex1.prod(c23,1));
	         cs36 = cplex1.sum(cs36,cplex1.prod(c21,-1));
	         cs36 = cplex1.sum(cs36,cplex1.prod(x312,1000));
	         cplex1.addLe(cs36,10000-8);
	         
	         cs37 = cplex1.sum(cs37,cplex1.prod(c22,1));
	         cs37 = cplex1.sum(cs37,cplex1.prod(c23,-1));
	         cs37 = cplex1.sum(cs37,cplex1.prod(x232,1000));
	         cplex1.addLe(cs37,1000-7);
	         
	         cs38 = cplex1.sum(cs38,cplex1.prod(c23,1));
	         cs38 = cplex1.sum(cs38,cplex1.prod(c22,-1));
	         cs38 = cplex1.sum(cs38,cplex1.prod(x322,1000));
	         cplex1.addLe(cs38,1000-8);
  • (3,1),(3,2)构成的流程
             //(3,1),(3,2)构成的流程

	         //虚拟的开始工件0
	         cs39 = cplex1.sum(cs39,cplex1.prod(x013,1));
	         cs39 = cplex1.sum(cs39,cplex1.prod(x023,1));
	         cplex1.addEq(cs39,1);
	         
             //虚拟的结束工件0
	         cs40 = cplex1.sum(cs26,cplex1.prod(x1M3,1));
	         cs40 = cplex1.sum(cs26,cplex1.prod(x2M3,1));
	         cplex1.addEq(cs40,1);

	         //每一个中间节点只有一个紧前工序和一个紧后工序
	         cs41 = cplex1.sum(cs41,cplex1.prod(x013,1));
	         cs41 = cplex1.sum(cs41,cplex1.prod(x213,1));
	         cs42 = cplex1.sum(cs42,cplex1.prod(x123,1));
	         cs42 = cplex1.sum(cs42,cplex1.prod(x1M3,1));
	         cplex1.addEq(cs41,1);
	         cplex1.addEq(cs42,1);
	         
	         cs43 = cplex1.sum(cs43,cplex1.prod(x023,1));
	         cs43 = cplex1.sum(cs43,cplex1.prod(x123,1));
	         cs44 = cplex1.sum(cs44,cplex1.prod(x213,1));
	         cs44 = cplex1.sum(cs44,cplex1.prod(x2M3,1));
	         cplex1.addEq(cs43,1);
	         cplex1.addEq(cs44,1);

	         //紧前工序的完工时刻加上紧后工序的加工时间小于等于紧后工序的完工时刻
	         cs45 = cplex1.sum(cs45,cplex1.prod(c31,1));
	         cs45 = cplex1.sum(cs45,cplex1.prod(c32,-1));
	         cs45 = cplex1.sum(cs45,cplex1.prod(x123,1000));
	         cplex1.addLe(cs45,1000-6);
	         
	         cs46 = cplex1.sum(cs46,cplex1.prod(c32,1));
	         cs46 = cplex1.sum(cs46,cplex1.prod(c31,-1));
	         cs46 = cplex1.sum(cs46,cplex1.prod(x213,1000));
	         cplex1.addLe(cs36,1000-4);
  • (4,2),(4,3)构成的流程
             //(4,2),(4,3)构成的流程

	         //虚拟的开始工件0
	         cs47 = cplex1.sum(cs47,cplex1.prod(x024,1));
	         cs47 = cplex1.sum(cs47,cplex1.prod(x034,1));
	         cplex1.addEq(cs47,1);

	         //虚拟的结束工件0
	         cs48 = cplex1.sum(cs48,cplex1.prod(x2M4,1));
	         cs48 = cplex1.sum(cs48,cplex1.prod(x3M4,1));
	         cplex1.addEq(cs48,1);

	         //每一个中间节点只有一个紧前工序和一个紧后工序
	         cs49 = cplex1.sum(cs49,cplex1.prod(x024,1));
	         cs49 = cplex1.sum(cs49,cplex1.prod(x324,1));
	         cs50 = cplex1.sum(cs50,cplex1.prod(x234,1));
	         cs50 = cplex1.sum(cs50,cplex1.prod(x2M4,1));
	         cplex1.addEq(cs49,1);
	         cplex1.addEq(cs50,1);
	         
	         cs51 = cplex1.sum(cs51,cplex1.prod(x034,1));
	         cs51 = cplex1.sum(cs51,cplex1.prod(x234,1));
	         cs52 = cplex1.sum(cs52,cplex1.prod(x324,1));
	         cs52 = cplex1.sum(cs52,cplex1.prod(x3M4,1));
	         cplex1.addEq(cs51,1);
	         cplex1.addEq(cs52,1);

	         //紧前工序的完工时刻加上紧后工序的加工时间小于等于紧后工序的完工时刻
	         cs53 = cplex1.sum(cs53,cplex1.prod(c42,1));
	         cs53 = cplex1.sum(cs53,cplex1.prod(c43,-1));
	         cs53 = cplex1.sum(cs53,cplex1.prod(x234,1000));
	         cplex1.addLe(cs53,1000-3);
	         
	         cs54 = cplex1.sum(cs54,cplex1.prod(c43,1));
	         cs54 = cplex1.sum(cs54,cplex1.prod(c42,-1));
	         cs54 = cplex1.sum(cs54,cplex1.prod(x324,1000));
	         cplex1.addLe(cs54,1000-5);

5.求解

//求解
	         if(cplex1.solve()) {
	        	 cplex1.output().println("Solution status = " + cplex1.getStatus());
	        	 cplex1.output().println("Solution value = " + cplex1.getObjValue());
	        	 double val1 = cplex1.getValue(x121);
	        	 double val2 = cplex1.getValue(x211);
	        	 double val3 = cplex1.getValue(x131);
	        	 double val4 = cplex1.getValue(x311);
	        	 double val5 = cplex1.getValue(x231);
	        	 double val6 = cplex1.getValue(x321);
	        	 double val7 = cplex1.getValue(x122);
	        	 double val8 = cplex1.getValue(x212);
	        	 double val9 = cplex1.getValue(x132);
	        	 double val10 = cplex1.getValue(x312);
	        	 double val11 = cplex1.getValue(x232);
	        	 double val12 = cplex1.getValue(x322);
	        	 double val13 = cplex1.getValue(x123);
	        	 double val14 = cplex1.getValue(x213);
	        	 double val15 = cplex1.getValue(x234);
	        	 double val16 = cplex1.getValue(x324);
	        	 
	        	 System.out.println("x121="+val1);
	        	 System.out.println("x211="+val2);
	        	 System.out.println("x131="+val3);
	        	 System.out.println("x311="+val4);
	        	 System.out.println("x231="+val5);
	        	 System.out.println("x321="+val6);
	        	 System.out.println("x122="+val7);
	        	 System.out.println("x212="+val8);
	        	 System.out.println("x132="+val9);
	        	 System.out.println("x312="+val10);
	        	 System.out.println("x232="+val11);
	        	 System.out.println("x322="+val12);
	        	 System.out.println("x123="+val13);
	        	 System.out.println("x213="+val14);
	        	 System.out.println("x234="+val15);
	        	 System.out.println("x324="+val16);
	        	 
	         }
	        	
	        	 cplex1.end();

上善若水阳阳
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java 调用 Cplex 使用手册
03-24
java 调用 Cplex 使用手册， CPLEX Tutorial Handout。
使用CPLEX求解小规模能量高效的FJSP
qq_36820823的博客
11-29 5389
CPLEX求解 energy-efficient flexible job shop scheduling problem的MILP
JSP（机器调度问题）使用java进行数学建模并调用cplex求解
whq002的博客
07-29 2100
JSP（机器调度问题）使用java进行数学建模并调用cplex求解
基于Cplex求解器的JavaAPI语法使用
博客简介
05-22 1453
通过"// 定义一个浮点型的决策变量lb：lower bound，变量的下届ub：upper bound，变量的上届变量类型：：连续变量“x”：变量的名字，可选择的项整形变量通过// 写法1：定义一个整型的决策变量// 写法2：以上写法等价于如下写法，从源码来看，model.intVar()方法内部还是调用了model.numVar()方法，因此两种写法等价，但此时不在需要传参IloNumVarType.Int：0-1变量通过进行定义：还有另一种简单写法，即。
java调用cplex实现经典Benders分解算法求解混合整数规划问题
weixin_37980595的博客
06-08 2257
Benders分解算法是由Jacques F. Benders在1962年首先提出，目的是用于解决混合整数规划问题(MIP问题)，即连续变量与整数变量同时出现的极值问题。随着分解算法的不断演变，不严格要求问题形式的广义Benders分解算法被A.M. Geoffrion提出，实现了对具有Benders分解基本形式的非线性问题求解，也就是说在广义Benders分解算法对子问题的求解方法也不必一定是线性的。这里仅对经典的Benders分解算法进行简要说明。经典的Benders分解算法将决策变量分为简单变量和复杂
【运筹优化】运输问题建模 + Java调用Cplex求解
最新发布
知不足而奋进，望远山而前行
08-16 1969
运输问题(transportation problem）一般是研究把某种商品从若干个产地运至若干个销地而使总运费最小的一类问题。在料场与工地之间计算一个距离弧，然后将分配到弧上的运输量作为决策变量，从而建立线性规划模型调用Cplex求解。本博客将根据下面的例题，介绍运输问题的建模和求解。的欧几里得距离（km），运输的水泥量（吨），
Java调用CPLEX官方示例——Blend.java
qq_42197128的博客
04-09 589
Java调用CPLEX官方示例——Blend.java 金属混合问题
调用CPLEX求解优化问题的简化方法
11-13
调用CPLEX求解优化问题的简化方法调用CPLEX求解优化问题的简化方法
java调用cplex实现列生成算法求解切割下料问题
05-29
java调用cplex实现列生成算法求解切割下料问题 列生成（Column generation）算法是一种用于求解大规模线性优化问题的非常高效的算法，被应用于调度问题、切割问题、车辆路径问题、选址问题等。 列生成算法是一种可...
python调用cplex解决tsp问题
08-06
Python调用Cplex解决TSP问题是一个典型的组合优化问题，其中Cplex是一个强大的数学优化求解器，由IBM开发，广泛应用于线性规划、整数规划、二次规划以及图论问题，如旅行商问题（TSP）。在这个场景下，我们将探讨...
java 中使用Cplex的jar包
07-18
在Java中调用cplex必须使用到的jar包，具体的使用方法可以看我的博客哟
cplex Java jar包和配置方式
12-06
CPLEX的配置方式，有详细的配置Java调用CPLEX的方式已经cplex.jar包。
cplex_java:使用JAVA的CPLEX的优化问题（简介）
05-13
基础这是一个优化问题，仅用三个约束表示为最大化。 目的是说明如何将Java ... 使用Java的cplex API解决了该问题， []该类使用32位cplex程序。 如果您使用其他版本的cplex或Java，则必须相应地修改inn .classpath文件。
CPLEX求解器入门案例
诸葛小猿
10-20 1万+
官方中文JAVA手册：https://www.ibm.com/docs/zh/icos/12.9.0?topic=application-structure cplex是IBM开发的一款线性规划问题的求解器。 一、适用范围 cplex适用于求解的问题类型： CPLEX的适用范围： 1.适用于一般的线性规划（LP）问题. 2.CPLEX 还可对 LP 的多个扩展求解： 2.1.网络流问题，是 LP 的一种特殊情况，CPLEX 可以通过利用问题结构以快得多的速度对其求解。
如何在java中调用cplex (Cplex in Java)
coChen666的博客
07-18 6190
注意， 必要条件： ;J:\IBM\ILOG\CPLEX_Studio1271\cplex\bin\x64_win64;J:\IBM\ILOG\CPLEX_Studio1271\cplex\lib\cplex.jar 添加到环境变量path中； 将cplex.jar放到工程中并添加进路径； 将;J:\IBM\ILOG\CPLEX_Studio1271\cplex\bin\x64_win64添...
线性最优解java实现+Cplex java调用
热门推荐
hyy_blue的博客
07-05 3万+
一：cplex的使用： 1.1 导入cplex.jar,包的地址：https://pan.baidu.com/s/1Q0Bv24EQdelV2rY-IrLoZQ 提取码：xn14 1.2 将cplex1290.dll （地址：https://pan.baidu.com/s/1sQXqYTSJWywwaZt5AHVkZQ 提取码：nm0l）添加到VM option中，这里以IDEA为例， 同...
java调用Cplex：添加约束
softbreezee的博客
04-27 4985
由于课题相关要用到cplex，但是一直都没有时间好好查看api，导致自己以前写的代码过于冗长，今天简单介绍一种添加约束的方法。例如添加约束，拿着个约束用两种添加方式举例：，V=DUC// 车辆数约束 IloNumExpr[][] tempCar0 = new IloNumExpr[d][c]; for (int i = 0; i < d; i++) { for (int j = 0; j ...
JSP作业车间调度问题及约束整理
qq_42544836的博客
07-14 2073
作业车间调度问题的数学描述作业车间调度问题（JSP）一般被描述为：在给定每个工件的加工工艺、每个工件使用机器的序列及每个工件每道工序的加工时间的情况下，安排一种工件的加工顺序，使得n个待加工的工件在m台机器上进行加工，满足某种性能指标最优化。本文所使用的性能指标为“最小化最大完工时间”，且该问题需要满足如下假设及约束： a）机器不发生故障，从零时刻开始加工工件。 b）同一台机器在同一时刻只能加工一个工件；同一工件同一时刻只能在一台机器上加工。 c）工件的加工工序严格遵守加工时间，一旦开始不得中断；工序间不允
Java调用cplex求解cvrp问题
05-23
CPLEX是一款高效的数学优化求解器，可以用来求解各种类型的优化问题，包括车辆路径规划问题（CVRP）。Java可以通过JNI（Java Native Interface）技术来调用C++编写的CPLEX库，从而实现对CVRP问题的求解。 以下是一个简单的Java调用CPLEX求解CVRP问题的示例代码： ```java import ilog.concert.*; import ilog.cplex.*; public class CVRP { public static void main(String[] args) { try { // 创建Cplex对象 IloCplex cplex = new IloCplex(); // 创建变量 int n = 10; // 节点数 int m = 3; // 车辆数 double[][] d = new double[n][n]; // 距离矩阵 IloIntVar[][] x = new IloIntVar[n][n]; // x[i][j]表示从i到j是否有路径 IloIntVar[] u = new IloIntVar[n]; // u[i]表示第i个节点的负荷 for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { x[i][j] = cplex.boolVar(); } u[i] = cplex.intVar(0, 10000); // 假设每个节点的最大负荷为10000 } // 添加约束 for (int i = 1; i < n; i++) { IloLinearNumExpr expr1 = cplex.linearNumExpr(); for (int j = 0; j < n; j++) { if (j != i) { expr1.addTerm(1.0, x[i][j]); } } cplex.addEq(expr1, 1.0); // 每个节点只能被访问一次 IloLinearNumExpr expr2 = cplex.linearNumExpr(); for (int j = 0; j < n; j++) { if (j != i) { expr2.addTerm(1.0, x[j][i]); } } cplex.addEq(expr2, 1.0); // 每个节点只能从一个节点到达 cplex.addLe(u[i], m); // 每个车辆的最大负荷不能超过车辆数 } for (int j = 0; j < n; j++) { IloLinearNumExpr expr3 = cplex.linearNumExpr(); for (int i = 0; i < n; i++) { if (i != j) { expr3.addTerm(1.0, x[i][j]); } } cplex.addEq(expr3, 1.0); // 每个节点只能到达一次 } for (int i = 1; i < n; i++) { for (int j = 1; j < n; j++) { if (i != j) { cplex.addLe(cplex.sum(u[j], cplex.prod(-1, u[i]), cplex.prod(n - 1, x[i][j])), n - 2); // 车辆容量约束 } } } // 添加目标函数 IloLinearNumExpr obj = cplex.linearNumExpr(); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i != j) { obj.addTerm(d[i][j], x[i][j]); } } } cplex.addMinimize(obj); // 求解问题 cplex.solve(); // 输出结果 System.out.println("Objective value = " + cplex.getObjValue()); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i != j && cplex.getValue(x[i][j]) > 0.9) { System.out.println("Vehicle " + (i + 1) + " -> " + (j + 1)); } } } // 释放资源 cplex.end(); } catch (IloException e) { e.printStackTrace(); } } } ``` 这段代码实现了一个简单的CVRP求解过程，其中包括创建变量和约束、设置目标函数、求解问题以及输出结果。需要注意的是，在实际的CVRP问题中，还需要考虑许多其他因素，如时间窗口、多重配送等，需要根据实际情况进行相应的调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

上善若水阳阳

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

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

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

打赏作者

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

抵扣说明：

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

余额充值