Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1663488
  • 博文数量: 607
  • 博客积分: 10031
  • 博客等级: 上将
  • 技术积分: 6633
  • 用 户 组: 普通用户
  • 注册时间: 2006-03-30 17:41
文章分类

全部博文(607)

文章存档

2011年(2)

2010年(15)

2009年(58)

2008年(172)

2007年(211)

2006年(149)

我的朋友

分类: LINUX

2006-12-26 19:32:58

GNU 线性编程工具包(GNU Linear Programming Kit),第 3 部分: 高级问题和最佳解决方案

香水利润的最大化和更好篮球队的组建

developerWorks
文档选项

未显示需要 JavaScript 的文档选项

将此页作为电子邮件发送

将此页作为电子邮件发送


拓展 Tomcat 应用

下载 IBM 开源 J2EE 应用服务器 WAS CE 新版本 V1.1


级别: 中级

Rodrigo Ceron (), 资深软件工程师, IBM

2006 年 12 月 26 日

GNU 线性编程工具包(GNU Linear Programming Kit,GLPK)是一个功能强大的工具,被证明可以很好地解决具有多限制的数值问题。本文是 3 部分系列文章 中的第 3 篇,阐述如何使用 GLPK 和 glpsol 客户端工具结合 GNU MathProg 语言来解决香水生产问题和篮球阵容问题。

本文是 有关使用 GNU 线性编程工具包 的 3 部分系列文章中的第 3 篇。有关 GLPK 的简介,请阅读本系列文章的第 1 部分 “ GNU 线性编程工具包(GNU Linear Programming Kit),第 1 部分:线性优化简介”。

[样例问题中所有的公司和产品名都是虚构的。 -Ed.]

这个问题来自于 Wayne L. Winston 所著的 Operations Research: Applications and Algorithms, 4th Edition(Thomson,2004 年);请参阅 参考资料 中的链接。

Rylon 公司生产 Brute 和 Chanelle 香水。生产每种香水所需要的原料的购买价格是每磅 3 美元。处理每磅原料需要 1 小时的劳动时间。每磅原料可以生产 3 盎司的 Regular Brute Perfume 和 4 盎司的 Regular Chanelle Perfume。Regular Brute 的售价为每盎司 7 美元,Regular Chanelle 的售价为每盎司 6 美元。Rylon 公司还可以对 Regular Brute 和 Regular Chanelle 进行再加工来生产 Luxury Brute,其售价为每盎司 18 美元;以及 Luxury Chanelle,其售价为每盎司 14 美元。再加工每盎司 Regular Brute 还需要 3 小时的劳动时间和 4 美元的处理成本,才可以生产 1 盎司的 Luxury Brute。再加工每盎司 Regular Chanelle 还需要 2 小时的劳动时间和 4 美元的处理成本,才可以生产 1 盎司的 Luxury Chanelle。每年 Rylon 公司一共有 6000 小时的劳动时间,最多可以购买 4000 磅原料。请实现 Rylon 公司利润的最大化。

现在我们对这个问题的相关重要信息进行一下总结:

  • Rylon 公司生产 Brute 和 Chanelle 香水。
  • 原料成本是每磅 3 美元。
  • 处理每磅原料需要 1 小时的劳动时间。
  • 每磅原料可以生产 3 盎司的 Regular Brute Perfume 和 4 盎司的 Regular Chanelle Perfume。
  • Regular Brute 的售价为每盎司 7 美元,Regular Chanelle 的售价为每盎司 6 美元。
  • 再加工可以生产 Luxury Brute,其售价为每盎司 18 美元;以及 Luxury Chanelle,其售价为每盎司 14 美元。
  • 再加工每盎司 Regular Brute 还需要 3 小时的劳动时间和 4 美元的处理成本,才可以生产 1 盎司的 Luxury Brute。
  • 再加工每盎司 Regular Chanelle 还需要 2 小时的劳动时间和 4 美元的处理成本,才可以生产 1 盎司的 Luxury Chanelle。
  • 约束条件包括: 每年 6000 小时的劳动时间,Rylon 公司最多可以购买 4000 磅原料。

在对这个问题进行建模之前,让我们首先来看一下从原料到最终产品的转化过程:



Rylon 公司的生产过程概述

图 1 说明所有的原料都被转换成了中间产品(图中用中间的球表示)。中间上边这个球表示 Regular Brute 产品。有些 Regular Brute 可以再加工生成 Luxury Brute,因此这个球分成了两部分:被销售的 Regular Brute (绿色)和被再加工生成 Luxury Brute 的 Regular Brute(蓝色)。Chanelle 的情况也是如此。请注意这两个中间的球中只有蓝色的部分(而且蓝色部分会全部)会进行再加工。





回页首


这个特定问题的决策变量需要包括所有的香水和原料:

  • x1:每年销售 Regular Brute 的磅数
  • x2:每年销售 Luxury Brute 的磅数
  • x3:每年销售 Regular Chanelle 的磅数
  • x4:每年销售 Luxury Chanelle 的磅数
  • x5:每年购买的原料的磅数

目标函数是要根据这些决策变量实现 Rylon 公司利润的最大化:


公式 1

这个问题中有几个小约束是有关处理原料所需的劳动时间的。Rylon 需要一些时间来加工自己购买的原料,其值由 x5 给出。将 Regular Brute 和 Chanelle 再加工成 Luxury Brute 和 Chanelle 是需要时间的,因此总共的时间取决于 x2x4 加上 x5


公式 2

Rylon 公司可以购买的原料的最大值也是一个约束:


公式 2-1

同样,符号约束也非常重要:


公式 3

如果这个模型被转换成 GNU MathProg 并使用 glpsol 进行分析,那么它会报告这个问题是无界的: Rylon 生产的产品越多,它的获利也就越多。要是公司能迁移到加勒比海,这倒是个不错的业务,但很明显这不太可能。那么问题出在什么地方呢?

原 材料需要制造成 Regular Brute 和 Chanelle,它们又可以进一步再制造成 Luxury 版本的香水。这两个变量应该怎样进行转换呢?原材料到 Chanelle 和 Brute 的转换并不是 1 对 1 的,这一点在问题描述中可以看到。每磅原材料可以产生 3 盎司的 Regular Brute 和 4 盎司的 Regular Chanelle(一共可以产生 7 盎司香水)。可以将这种转换过程看作是一个黑盒。如果将 1 磅原材料放到这个黑盒中,就可以从这个盒子中拿出 3 盎司 Regular Brute 4 盎司 Regular Chanelle。如果加工 N 磅原材料,那么 图 1 中中间上面的这个球就一定3N。这是 Regular 加上 Luxury Brute 的数量。

请记住 1 盎司 Regular Brute 和 Chanelle 香水都可以生产 1 盎司的 Luxury Brute 和 Chanelle 香水。另外,中间下面的这个球中的 Regular 和 Luxury Chanelle 总共应是 4N 盎司。Rylon 公司不能使用 N 磅原材料来生产 2N 盎司的 Regular Brute 和 Luxury Brute 及 5N 盎司的 Regular Chanelle 和 Luxury Chanelle。1 比 3 的 Brute 转换比例和 1 比 4 的 Chanelle 转换比例必须要保持不变,这与 Brute 和 Chanelle 产品中 Regular 和 Luxury 的比例无关。

所生产的香水必须一直由原材料生成。如果没有保持这种平衡,结果就可能是错误的。因此必须要遵守下面的约束:


公式 4

这 个公式说明所生产的所有 Brute(所销售的 Regular Brute 加上进行再生产所使用的 Regular Brute)除以 3 必须等于原材料的单位数量。这听起来对么?前面提到过加工一个单位的原材料(1 磅)可以生成 3 个单位(3 盎司)的 Regular Brute,而 1 个单位的 Regular Brute 可以转换成 1 盎司的 Luxury 产品。请再次注意 Regular Brute 加上 Luxury Brute 的单位(盎司)总数必须是所加工的原材料单位数的 3 倍。因此,这个约束看来没什么问题。因为 GLPK 需要所有决策变量都在等式相同的一边,所以需要将上面的公式改写成下面的形式:


公式 5

类似地,我们还有下面的公式:


公式 6

这个公式看起来正确么?一个单位的原材料可以生成 4 盎司的 Chanelle( Regular 加上 Luxury 产品),因此这也是正确的。在 GLPK 中,需要把这个公式中的决策变量都放到左边:


公式 7

现在,整个问题已经全部解决了。下面让我们为这个问题编写一个 GNU MathProg 程序。





回页首


glpsol 的下面代码可以解决 Rylon 问题(行号不是代码的一部分,添加这些代码只是为了简化后面对代码的引用)。



 1      #
2 # Rylon production proccess
3 #
4 # This finds the optimal solution for maximizing Rylon's profit
5 #
6 /* sets */
7 set PROD;
8
9 /* parameters */
10 param Rev{i in PROD};
11 param Cost{i in PROD};
12 param Labh{i in PROD};
13
14 var x{i in PROD} >= 0; /*x1: No. of oz of Regular Brute
15 x2: No. of oz of Luxury Brute
16 x3: No. of oz of Regular Chanelle
17 x4: No. of oz of Luxury Chanelle
18 x5: No. of lbs of raw material */
19
20 maximize z: sum{i in PROD} (Rev[i]*x[i] - Cost[i]*x[i]);
21
22 /* Constraints */
23 s.t. raw: x['raw'] <= 4000;
24 s.t. time: sum{i in PROD} Labh[i]*x[i] <= 6000;
25 s.t. mass1: x['rb'] + x['lb'] - 3*x['raw'] = 0;
26 s.t. mass2: x['rc'] + x['lc'] - 4*x['raw'] = 0;
27
28 data;
29 set PROD:= rb lb rc lc raw;
30
31 param Rev:=
32 rb 7
33 lb 18
34 rc 6
35 lc 14
36 raw 0;
37
38 param Labh:=
39 rb 0
40 lb 3
41 rc 0
42 lc 2
43 raw 1;
44
45 param Cost:=
46 rb 0
47 lb 4
48 rc 0
49 lc 4
50 raw 3;
51
52 end;

应该注意上面这段代码中所有的声明,为了完整起见,下面我们来快速浏览一下这些内容。

第 7 行声明了一个名为 PROD 的集合,它的元素是 Brute 和 Chanelle 产品。第 29 行定义了产品。这 4 个简写分别代表 Regular BruteLuxury BruteRegular ChanelleLuxury Chanelle,最后一个元素是原材料。原材料也作为一个产品列出来,这样所有的决策变量都可以在一个集合中了。

第 10、11 和 12 行声明了几个参数:收入、成本和劳动时间。其参数是在第 31 行到 50 行中定义的。工作时间表明了处理 1 磅原材料以及将 Regular Brute 和 Chanelle 再加工成 Luxury 版本(每盎司)需要多少时间。成本包含每磅原材料的成本以及再加工每磅 Regular Brute 和 Chanelle 的成本。

第 14 行定义了决策变量,这是一个包含 5 个元素的 PROD 集合的数组。

第 20 行定义了目标函数,它是 Rylon 公司的利润(收入 - 成本)。

最后,第 23 到 26 行声明了这个问题的约束,这在前面已经讨论过了。

清单 2 给出了输出结果:



Problem:    brute
Rows: 5
Columns: 5
Non-zeros: 15
Status: OPTIMAL
Objective: z = 172666.6667 (MAXimum)

No. Row name St Activity Lower bound Upper bound Marginal
------ ------------ -- ------------- ------------- ------------- -------------
1 z B 172667
2 raw NU 4000 4000 39.6667
3 time NU 6000 6000 2.33333
4 mass1 NS 0 -0 = 7
5 mass2 NS 0 -0 = 6

No. Column name St Activity Lower bound Upper bound Marginal
------ ------------ -- ------------- ------------- ------------- -------------
1 x[rb] B 11333.3 0
2 x[lb] B 666.667 0
3 x[rc] B 16000 0
4 x[lc] NL 0 0 -0.666667
5 x[raw] B 4000 0

Karush-Kuhn-Tucker optimality conditions:

KKT.PE: max.abs.err. = 1.46e-11 on row 1
max.rel.err. = 8.43e-17 on row 1
High quality

KKT.PB: max.abs.err. = 0.00e+00 on row 0
max.rel.err. = 0.00e+00 on row 0
High quality

KKT.DE: max.abs.err. = 8.88e-16 on column 2
max.rel.err. = 5.92e-17 on column 2
High quality

KKT.DB: max.abs.err. = 0.00e+00 on row 0
max.rel.err. = 0.00e+00 on row 0
High quality

End of output

第一部分显示解是最佳的,目标函数约等于 172667。第三部分给出了每个决策变量的值。第二部分给出了约束。注意数量守恒约束通常在 bound 列中都有一个 = 号。它们的边界值不能进行分析,因为使用一个具有等式约束的边界值没有任何意义。这一点您同意吗?如果您有不同的观点,请给我发邮件。

下面让我们来进行一个简要的分析。Rylon 已经处理了 4000 磅原材料。根据数量守恒(黑盒按照一定的比例将原材料转换成 Chanelle 和 Brute),需要确保 N 磅的原材料可以生产 3N 盎司的 Brute(Regular 加上 Luxury) 4N 盎司的 Chanelle(Regular 加上 Luxury)。这里有 16000 盎司的 Regular Chanelle 以及 0 盎司的 Luxury Chanelle。因此对于 Chanelle 的比例是 1(4000 磅)比 4(16000 盎司)。类似地,对于 Brute 的比例是 1(4000 磅)比 3(11333.333 盎司加上 666.667 盎司)。很好,我们现在接触到实际问题了。

如果没有这种数量守恒约束,glpsol 就会将下面的错误打印到 stdout 上:



Reading model section from brute-production2.mod...
Reading data section from brute-production2.mod...
61 lines were read
Generating z...
Generating raw...
Generating time...
Model has been successfully generated
lpx_simplex: original LP has 3 rows, 5 columns, 9 non-zeros
PROBLEM HAS NO DUAL FEASIBLE SOLUTION
If you need actual output for non-optimal solution, use --nopresol
Time used: 0.0 secs
Memory used: 0.1M (149646 bytes)
lpx_print_sol: writing LP problem solution to `brute-production2.sol'...

结果表明这个问题没有对偶的可行方案,不过这是什么意思呢?每个问题都有对偶性。例如,最大化问题可以重写为一个最小化问题。在这个意义上最大化问题会被称为初始问题,最小化问题就称为对偶问题。如果初始问题是一个最小化问题,那么其对偶问题就是一个最大化问题。通俗地说,对偶问题就意味着是次要问题或可选问题,而原始问题则意味着主要问题。

无解的原始问题就会有一个无界的对偶问题。无界的原始问题也会有一个不可行的对偶问题。由于 glpsol 断言对偶问题不可行,因此原始问题就是无界的(这就是我们前面谈到的加勒比海岛的情况)。





回页首


本节将介绍一个具有多种最佳解的简单问题。本系列文章到目前为止所给出的所有问题都只有一个最佳解。具有多个解的问题在其可行域中有多个点可以实现问题的最大化或最小化。不管怎样,这些关键点的目标函数是相同的。下面是一个例子。





回页首


最大化下面的目标函数:


公式 8

并遵守下面两个约束:


公式 9

公式 10

这个特定问题的可行域如图 2 中的灰色区域所示。



多解问题的可行域

在为这个问题寻找最佳解而编写 GNU MathProg 程序之前,需要对其稍微进行一下分析。在本系列文章 第 2 部分 中曾经介绍过目标函数朝最大化问题的发展方向。最佳解通常都是其可行域所构成的多面体的一个顶点。当目标函数的方向导数与这个多面体(由约束构成)的一个面垂直时,此多面体上的这个面上的所有点对于这个目标函数来说都具有相同的值,因为它们都在同一个 iso-quanta 上。

iso-quanta 是由具有相同目标函数值的点所构成的空间中的一条线。在这个问题中,x1+x2=1 就是一个 iso-quanta, x1+x2=2 是另外一个 iso-quanta,依此类推。如果约束线是沿这个目标函数的方向导数距离最远的一条线,并且与该导数垂直,那么这个可行域边界上所有的点都可以使这个目标解达到最佳值。





回页首


下面是 GNU MathProg 对多解问题的解决方案:



 1  #
2 # Multiple solution problem
3 #
4 # This finds the optimal solution for a simple multiple solution problem
5 #
6
7 /* decision variables */
8 var x1 >=0;
9 var x2 >=0;
10
11 /* objective function */
12 maximize z: x1 + x2;
13
14 /* constraints */
15 s.t. Ctr: x1 + x2 <= 5;
16
17 end;

这个非常简单的程序声明了两个决策变量:约束和目标函数。

清单 5 给出了结果:



Problem:    multiple
Rows: 2
Columns: 2
Non-zeros: 4
Status: OPTIMAL
Objective: z = 5 (MAXimum)

No. Row name St Activity Lower bound Upper bound Marginal
------ ------------ -- ------------- ------------- ------------- -------------
1 z B 5
2 Ctr NU 5 5 1

No. Column name St Activity Lower bound Upper bound Marginal
------ ------------ -- ------------- ------------- ------------- -------------
1 x1 B 5 0
2 x2 NL 0 0 < eps

Karush-Kuhn-Tucker optimality conditions:

KKT.PE: max.abs.err. = 0.00e+00 on row 0
max.rel.err. = 0.00e+00 on row 0
High quality

KKT.PB: max.abs.err. = 0.00e+00 on row 0
max.rel.err. = 0.00e+00 on row 0
High quality

KKT.DE: max.abs.err. = 0.00e+00 on column 0
max.rel.err. = 0.00e+00 on column 0
High quality

KKT.DB: max.abs.err. = 0.00e+00 on row 0
max.rel.err. = 0.00e+00 on row 0
High quality

End of output

这个解是最佳的,目标函数的值是 5。这个报告的第二部分说明这个约束是有界的,其边界值是 1。

在第三部分中,变量 x2 在其下界上,并具有一个边界值。这个边界值显示为 ,这是 GLPK 在内部使用的精度的单位(在数学理论中,epsilon 通常用来说明这是一个非常小的数字,eps 是 epsilon 的缩写)。比最小精度再小的数字可能就是 0 了。因此,如果 x2 变量还可以再变化,那么目标函数的值只会变化 0。换而言之,当约束使用新的 (x1, x2) 对时,x2 的变化不会引起目标函数值的变化。因此在这个可行域中有多个点对于目标函数来说会产生相同的值。这个问题具有多个解!

请记住不论何时只要 glpsol 报告一个变量的边界值是 ,这就说明它是一个具有多个解的问题。





回页首


集合覆盖问题涉及的是二元决策变量;也就是说,它们的值只能是 0 或 1、yes 或 no。

篮 球教练想要组建自己的球队来参加一场比赛。这个球队含 7 个球员,其中 5 个球员可以在场上比赛。每个球员在助攻、防守、投篮和篮板方面的能力可以被评价为 1(较差)到 3(很好)。他们在球场中的位置有 3 个:后场(B)、中场(M)和前场(F)。每个球员在球场中的位置及其能力如表 1 所示。


球员位置助攻投篮篮板防守
1B3313
2M2132
3BM2322
4MF1331
5BF1312
6MF3123
7BF3221

所选择的 5 个球员必须能够一起满足下面的约束条件:

  • 至少有 3 个球员可以打后场位置。
  • 至少有 2 个球员可以打前场位置。
  • 至少有 1 个球员可以打中场位置。
  • 整个球队的助攻、篮板、防守和投篮的平均能力至少为 2。
  • 如果球员 3 正在场上比赛,那么球员 6 就不能比赛,反之亦然。
  • 如果球员 1 正在场上比赛,那么球员 4 和 5 也必须在场上比赛。
  • 球员 2 或 3 必须参加比赛。

目标是在这场比赛中实现防守能力的最大化。





回页首


首先,要决定使用哪些决策变量。整个球队中有 7 个球员。但是哪 5 个球员应该上场比赛呢?7 个二元变量会确定每个球员 i 会上场比赛(决策变量为 1)还是不上场比赛(0):


公式 11

目标函数是寻找所有球员的防守能力的最大值。


公式 12

并不需要将目标函数除以 5 来获得平均值,因为 f(x) 最大化的条件与 f(x) 除以 CONSTANT 最大化的条件是相同的。换而言之,除法并不会改变目标函数最大化的方向。

接下来分析一下各个约束。第一个约束要求至少有 3 个球员必须能够打后场的位置。只有球员 1、3、5、7 能够打这个位置:


公式 13

因此,这个约束可以确保这 4 个二元变量中至少有 3 个为 1。

类似地,对于中场这个位置来说,球员 2、3、4 和 6 中必须有一个要上场:


公式 14

前场位置需要球员 4、5、6、7 中的两个。


公式 15

助攻、篮板、防守和投篮的平均能力必须至少为 2:


公式 16-19

第 5 个约束要求如果球员 3 上场比赛,那么球员 6 就不能上场比赛,反之亦然。因此这两个球员只有一个能上场比赛:


公式 20

对于这个公式来说,如果 y3=1,那么这个约束会强制 y6 是 0,反之亦然。这个约束强制球员 1 或 6 必须在这个球队中参加比赛。这与教练的意图并不完全相同。他们偶尔也可能都不参加比赛,上述公式没有考虑到这一点。


公式 21

现在,如果 y3=1,那么 y6=0,因为其和不能大于 1。如果 y6=1,那么 y3=0。如果 y3y6 都为 0 ,那么这个公式也是对的。

第 6 个约束声明当球员 1 上场比赛时,球员 4 和 5 也必须上场比赛(可能这已经签订到他们的合同中了)。因此当 y1=1 时,y4y5 也必须是 1:


公式 22-23

这个不等式有些技巧。如果 y1=0,那么 y4 >= 0。这意味着如果球员 1 没有上场比赛,那么球员 4 可能就在场上比赛。然而,如果球员 1 在场上比赛,那么 y4 >= 1,因此 y4 就等于 1。当球员 1 在场上比赛时,球员 4 也在场上比赛。对于球员 5 也会强制采用相同的不等式。

最后一个约束要求球员 2 或 3 必须要上场比赛。请注意它们不能同时上场参加比赛:


公式 24

还记得有关球员 3 和 6 的约束的第一个尝试么?这个约束强制球员 2 或 3 上场参加比赛,但不能同时上场。

这里还有一个隐藏约束:一个篮球队在场上最多只能有 5 名球员。因此:


公式 25

为了确保决策变量都是二元的,它们应该声明为只能是二元集合中的一个值:


公式 26

由于这个问题实际上是选择决策变量来满足一些约束,因此把它称为集合覆盖问题。





回页首


同上,代码中的行号也不是代码本身的一部分。增加这些行号只是为了稍后引用代码方便。



 1      #
2 # Basketball problem
3 #
4 # This finds the optimal solution for maximizing the team's overall
5 # defensive skill
6 #
7
8 /* sets */
9 set SKILLS;
10 set POSITIONS;
11 set PLAYERS;
12
13 /* parameters */
14 param skill {i in PLAYERS, j in SKILLS};
15 param position {i in PLAYERS, j in POSITIONS};
16 param min_in_position {i in POSITIONS};
17 param min_skill_average {i in SKILLS};
18
19 /* decision variables: yi, i in {1,..,7}. yi = 1 -> player i is on team */
20 var y {i in PLAYERS} binary >=0;
21
22 /* objective function */
23 maximize z: sum{i in PLAYERS} skill[i,"defense"]*y[i];
24
25 /* Constraints */
26 s.t. pos{j in POSITIONS}: sum{i in PLAYERS}
position[i,j]*y[i] >= min_in_position[j];
27 s.t. players: sum{i in PLAYERS} y[i] = 5;
28 s.t. ctr3: y[3] + y[6] <= 1;
29 s.t. ctr4a: y[4] - y[1] >= 0;
30 s.t. ctr4b: y[5] - y[1] >= 0;
31 s.t. ctr5: y[2] + y[3] = 1;
32 s.t. average{j in SKILLS}: sum{i in PLAYERS}
skill[i,j]*y[i]/5 >= min_skill_average[j];
33
34 data;
35 set PLAYERS := 1 2 3 4 5 6 7;
36 set POSITIONS := Back Mid Front;
37 set SKILLS := assist throw rebound defense;
38
39 param min_in_position:=
40 Back 3
41 Mid 1
42 Front 2;
43
44 param min_skill_average:=
45 assist 2
46 throw 2
47 rebound 2
48 defense 2;
49
50 param position: Back Mid Front:=
51 1 1 0 0
52 2 0 1 0
53 3 1 1 0
54 4 1 0 1
55 5 1 0 1
56 6 0 1 1
57 7 1 0 1;
58
59
60 param skill: assist throw rebound defense:=
61 1 3 3 1 3
62 2 2 1 3 2
63 3 2 3 2 2
64 4 1 3 3 1
65 5 1 3 1 2
66 6 3 1 2 3
67 7 3 2 2 1;
68
69 end;

它有 4 个参数:

  • skill 是一个二维表,其中 i 表示球员,j 列出他们的技能。这个表的值是以数字形式表示的球员 i 的技能 j

  • position 是一个二维二元表,i 表示球员,j 列出位置。这个表决定了球员 i 是否可以打位置 j (该值是否为 1)。

  • min_in_position 是在 POSITIONS 集合上定义的,用来定义可以打位置 i 的最少球员个数。

  • min_skill_average 是在 SKILLS 集合上定义的,用来定义针对技能 i,上场球员所必须具有的技能最小平均值。在本例中对于所有运动员这个平均值是相同的,但是在教练需要调整球队实力的情况下,它应该单独进行声明。

这个问题的核心是将决策变量声明成二元变量。这与将它们声明为整型变量一样容易。只需要向声明中添加一个 binary,如 20 行所示。

输出结果如下:



Problem:    basketball
Rows: 13
Columns: 7 (7 integer, 7 binary)
Non-zeros: 62
Status: INTEGER OPTIMAL
Objective: z = 11 (MAXimum) 11 (LP)

No. Row name Activity Lower bound Upper bound
------ ------------ ------------- ------------- -------------
1 z 11
2 pos[Back] 3 3
3 pos[Mid] 2 1
4 pos[Front] 3 2
5 players 5 5 =
6 ctr3 1 1
7 ctr4a 0 -0
8 ctr4b 0 -0
9 ctr5 1 1 =
10 average[assist]
2 2
11 average[throw]
2.2 2
12 average[rebound]
2 2
13 average[defense]
2.2 2

No. Column name Activity Lower bound Upper bound
------ ------------ ------------- ------------- -------------
1 y[1] * 1 0 1
2 y[2] * 1 0 1
3 y[3] * 0 0 1
4 y[4] * 1 0 1
5 y[5] * 1 0 1
6 y[6] * 1 0 1
7 y[7] * 0 0 1

End of output

请注意所有的决策变量都是 0 或 1,这与我们期望的一样。





回页首


本系列文章一共分析了 6 个问题,每个问题都引入了一个新的概念,我们对这些问题都进行了建模,也都采用 GNU MathProg 语言以一种简单优雅的方式编写了相应的程序以便 GLPK 能够解决该问题,另外我们还对结果进行了分析。

使用线性编程和运筹学理论来寻找最佳解并不限于本系列文章中所介绍的这些问题,诸如石油、化学、食物和金融之类的领域都可以充分利用线性方法和运筹学理论。

我鼓励大家使用并共享此处讨论的概念,这样就会有更多人可以了解到线性编程和运筹学的强大功能。我希望这些资料对大家有所帮助。



学习
  • 您可以参阅本文在 developerWorks 全球站点上的 英文原文

  • 阅读本 GLPK 系列文章 的所有内容(developerWorks,2006 年 8 月和 9 月)。

  • 本文的问题是从 (Wayne L. Winston 著,Thomson 2004 年出版)中摘取出来的。

  • 提供了更多有关 GLPK、 以及如何加入 GLPK 社区的信息。

  • 订阅 GLPK 或 。

  • developerWorks Linux 专区 中可以找到为 Linux 开发人员准备的更多资源。

  • 随时关注 developerWorks 技术事件和网络广播

获得产品和技术
  • 订购免费的 SEK for Linux,这有两张 DVD,包括最新的 IBM for Linux 的试用软件,包括 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere®。

  • 在您的下一个开发项目采用 IBM 试用软件 ,这些软件可以从 developerWorks 上直接下载。


讨论



Rodrigo Ceron Ferreira de Castro 是 IBM Linux Technology Center 的一名资深软件工程师。他在 2004 年毕业于 State University of Campinas(UNICAMP)。毕业时他获得了 State Engineering Institute 奖和 Engineering Council Certification of Honor 的荣誉。他在巴西和其他国家举办的开放源码会议上进行过多次演讲。

阅读(1369) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~