0-1规划的隐枚举法

合集下载

例析0-1整数规划及隐枚举法的应用

例析0-1整数规划及隐枚举法的应用

例析0-1整数规划及隐枚举法的应用自主招生近年来成为各大高校又一招纳人才的举措,面试在自主招生中扮演着越来越重要的角色,考生面试的成绩不容忽视。

因此如何确定面试专家的分配方案,使录取工作真正公平合理的进行,是各大高校积极考虑的问题。

本文通过采用0-1整数规划及隐枚举法建立相关模型,较好地解决了这一问题。

1 预备知识简介1.1 线性规划[1]在人们的生产实践中,经常会遇到如何利用现有资源来安排生产,以取得最大经济效益的问题。

此类问题构成了运筹学的一个重要分支——数学规划,而线性规划则是数学规划的一个重要分支。

若在线性规划模型中,变量限制为整数,则为整数线性规划。

0-1整数规划是整数规划中的特殊情形,它的变量仅取0或1。

合理地引用0-1规划能够容易且高效率地求解相关问题。

1.2 隐枚举法[2]隐枚举法是Balas E在1965年提出的,是求解0-1规划问题的一种有效方法。

它只检查一部分变量组合,在这过程中根据已有信息自动舍弃许多不可能成为最优解的组合,求得最优解,从而大大减少了工作量。

隐枚举法只需比较目标函数在小部分组合点上的取值大小,就能求得最优解和最优值。

2 问题描述与建模2.1 问题描述某高校采用通过专家面试的方式进行自主招生,经过初选合格进入面试的考生有N人,拟聘请老师M人进行面试。

每位学生要分别接收“面试组”每位老师的单独面试,每个面试组由4名老师组成。

已知要求面试不同考生的“面试组”成员不能完全相同。

试求在考生数N已知的条件下,聘请老师数M至少应为多大,才能做到任两位学生的“面试组”都没有两位面试老师相同。

2.2 数学建模该问题是一个单目标规划问题,解决的是满足一定约束条件要求,计算在给出一定的学生人数下,所需要教师的最少人数。

根据实际情况分析,一般面试学生的个数要远大于教师的个数。

因为教师人数较少,容易进行分组(即按照约束条件将教师每4人分成一组),满足约束条件的情况下,所能组合的最大组数目即可面试学生的最大人数[3~4]。

01规划问题深入剖析

01规划问题深入剖析
x=y0+2y1+22y2+….2kyk x1 7 x2 5 x3 3 x1=y01+2y11+22y21 x2=y02+2y12+22y22 x3=y03+2y13
x4 3
x4=y04+2y14
代入原问题,得到:
Max Z= 3 y01+6y11+12y21 + 4y02+8y12+16y22 + 5 y03+10y13 + 6 y04+12y14
改进过滤性条件Z 5
循 (X2,X1,X3) 环 3 (0,1,0) 4 (0,1,1)
(0’)
s.t. s.t. s.t s.t s.t 满 Z 0’ 1 .2 .3 .4 足 值 3 no 8 0 2 1 1 ye 8 s
改进过滤性条件Z 8 (0’’)
循 (X2,X1,X3) 环 5 (1,0,0) 6 (1,0,1) 7 (1,1,0) 8 (1,1,1) s.t. s.t. s.t s.t s.t 满 Z 0’’ 1 .2 .3 .4 足 值 -2 no 3 no 1 no 6 no
5
指派问题(分配问题) (Assignment Problem)
例5-11 有一份中文说明书,需 翻译成英、日、德、俄四种文字, 分别记作E、J、G、R,现有甲、 乙、丙、丁四人,他们将中文说 明书翻译成英、日、德、俄四种 文字所需时间如下,问应该如何 分配工作,使所需总时间最少?
任务 人员 甲 乙 丙
4 0-1规划的解法
0-1 规划在线性整数规划中具有重要地位。
定理:任何整数规划都可以化成0-1规划。
一般地说,可把整数x变成(k+1)个0-1变量公 式为:x=y0+2y1+22y2+….2kyk 若x上界为U,则对0<x<U,要求k满足2k+1 U+1.

解 0—1 规划的隐枚举法

解 0—1 规划的隐枚举法

(5)解 0—1 规划的隐枚举法解 0—1 规划的隐枚举法有其独特的工作程序,具体过程如下。

a.模型转化为求极小的问题b.变量替换。

极小问题模型的目标函数中所有变量系数为负的0—1变量,可利用变量替换x k=1-x'k (x'k是引入的新的0—1变量),将目标函数中所有变量系数化为正数。

c.目标函数中变量按系数大小排列,约束条件中变量排列顺序也相应调整。

d.按目标函数值由小到大的顺序依次排列可能的解,并予以可行性检验。

e.发现求极小问题的最优解并停止。

f.转化为原问题的最优解。

例4 用隐枚举法求解下列0—1规划问题Max Z=3x1+2x2-5x3-2x4+3x5x+x2+x3+2x4 +x5≤417x1 +3x3-4x4+3x5≤811x1-6x2 +3x4 +5x5≥3x=0, 1, j=1, 2, 3, 4, 5.j解:①转化为求极小的问题Min Z=-3x1-2x2+5x3+2x4-3x5-x1 -x2-x3-2x4 -x5≥-4-7x1 -3x3+4x4-3x5≥-811x1 -6x2 +3x4 +5x5≥3x=0, 1, j=1, 2, 3, 4, 5.j②令x'1=1-x1, x'2=1-x2, x'5=1-x5, 带入极小问题模型中,得Min Z=3 x'1+2 x'2+5x3+2x4+3 x'5-8x'+x'2-x3-2x4 +x'5≥-117x'1 -3x3+4x4+3x'5≥2-11x'1 +6x'2 +3x4-5x'5≥-7x=0, 1, j= 3, 4; x'j =0, 1, j= 1, 2, 5.j③目标函数中变量按系数大小排列,约束条件中变量排列顺序也相应调整,得Min Z=5x3+3 x'1+3 x'5+2 x'2+2x4-8-x3+x'1 +x'5+x'2-2x4 ≥-1 ①-3x3+ 7x'1 +3x'5 +4x4≥2②-11x'1 -5x'5+6x'2 +3x4≥-7 ③x=0, 1, j= 3, 4; x'j =0, 1, j= 1, 2, 5.j④按目标函数值由小到大的顺序排列可能的解,并予以可行性检验。

0-1规划介绍

0-1规划介绍

2.5 0-1规划在军队管理、作战指挥、计算机辅助决策中常常会碰到一类分配问题,又称指派问题。

这是指有m 个单位或人去完成,条件是(1)每项工作只能分配给一个单位或人去完成; (2)每个单位或人只能接受其中一项工作。

问题是怎样合理分配,才能使总的费用最小或总的效益最高?例16我军有1D 、2D 、3D 、4D 四个导弹阵地,同时射击地方1A 、2A 、3A 、4A 四架敌机。

根据敌机来袭方向和阵地位置等,算得每个导弹阵地对各架敌机的击毁概率如表2-21。

试给每个导弹阵地分配一架敌机,给每架敌机分配一个导弹阵地,使得对敌机的击毁概率最大。

解:设ij x 为问题的决策变量,它只取0,1两种值。

我们定义⎪⎩⎪⎨⎧=时。

分配给目标当不把阵地时,分配给目标当把阵地j i j i ij A D A D x 01i=1,2,3,4;j=1,2,3,4。

得线性规划444342413433323124232221141212112.08.09.06.08.06.08.04.06.08.06.08.06.04.09.06.0max x x x x x x x x x x x x x x x x P +++++++++++++++=表2-21 A 1A 2A 3A 4D 10.6 0.9 0.4 0.6 D 20.8 0.6 0.8 0.6 D 30.4 0.8 0.6 0.8 D 40.60.90.80.2约束于敌机 击毁概率 导 弹阵地⎪⎪⎪⎪⎪⎪⎩⎪⎪⎪⎪⎪⎪⎨⎧====+++=+++=++=+++=+++=+++=+++=+++4,3,2,1,4,3,2,1,,1,0111111114434241443332313423222124131211144434241343332312423222114131211j i x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x ij + 由于这个规划的决策变量只能取0,1两个值,故这种规划我们也称之为0-1规划。

0-1规划1

0-1规划1

0-1型整数线性规划0-1型整数线性规划是一类变量仅取0或1的特殊的整数规划;一般描述如下⎩⎨⎧===10),,1(..min 或取n i A t s f i x bx cx 其中),,(,)(,),,(),,,(111'=='==⨯m n m ij n n b b a A x x c c b x c 。

此时的决策变量称为0-1变量或二进制变量。

在实际问题中,如果引进0-1变量,就可以把各种需要分别讨论的线性(或非线性)规划问题统一在一个问题中讨论。

13.6.2 求解0-1线性规划的隐牧举法分枝定界法就是一种解整数规划的隐牧举法,0-1规划可以通过增加限定10≤≤i x 的整数规划来求解。

对于n 个变量的0-1规划,如果使用穷举法,则需要检查2n 个取值组合,这显然不是聪明的办法。

这里所说的隐牧举法,是根据0-1规划的特点,设计的一些方法,只检查变量组合的一部分,而不是全部。

值得说明的是,对于有些问题(例如一部分变量是0-1变量的混合线性规划)隐牧举法有时是不适用的,还得使用穷举法。

隐牧举法原理与算法步骤:(ⅰ)记∞=f f 0,将n 个决策变量构成的x 的2n 个取值组合按二进制(或某种顺序)排列;(ⅱ)按上述顺序对x 的取值首先检验0f f cx ≤=是否成立,若不成立则放弃该取值的x ,按次序换(ⅰ)中下一x 的取值重复上述过程;若成立,则转下一步;(ⅲ)对x 逐一检验b x A ≤中的m 个条件是否满足,一旦某一条件不满足便停止检验后面的条件,而放弃这一x 的取值,按次序换(ⅰ)中下一x 的取值执行(ⅱ),若m 个条件全满足,则转下一步;(ⅳ)记),,min(00f f f = 按次序换(ⅰ)中下一x 的取值,执行(ⅱ); (ⅴ)最后一组满足b x cx A f f ≤≤=和0的x 即为最优解。

求解0-1型整数线性规划的MATLAB 程序Ⅰ、转换十进制数为二进制数的程序如下是枚举和隐枚举程序中要调用的把十进制数转换为二进制数的程序。

0-1规划中并行隐枚举法的实现方式

0-1规划中并行隐枚举法的实现方式
关键词 01规 划 并行 计算 隐枚 举 法 -
I PLEM ENTI M NG APPRoACH FoR PARALLEL I PLI T M CI ENUM ERATI oN N 1 PROGRAM M D I 0. G
Z n n e g Ya
( eat etfC m ue Si c n e nl y C nrl hn o lU i rt,W h n私 0 7 , ue, hn ) Dp r n o p t c nea dTc o g , et i N r nv sy u a m o r e h o a C a ma ei D 9 H biC ia
An d,t ee i s mei r v me t d n t ei l i e u r t n O t ep o lm ih i h r e a c mp t g c n b 6v d b a all h r s o mp o e n ma eo h mp i t n me ai ,S r b e wh c s a d t s r l o u i a e s 1e y p r l c o h o i n e
mea in meh d i h e t y t o v t r t t o st e b s s l ei o wa o .Ac o dn ec aa trs co aa ll o u i g tc l s le bg a d c mp e r be a t c r ig t t h r c eit f r l mp t ,i al ov i n o l xp o lmsf s. oh i p ec n A t o o ii g t ep allc mp t g wi h mp i i e u r t n i p e e t d i i p p rt e o v h r b e me t n d a o e me d c mb n n h a l o u i t t e i l t n me ai s r s n e t s a e r s le t e p o l m n i e b v . h r e n h c o n h o o

关于求解0_1型整数规划的若干问题

关于求解0_1型整数规划的若干问题

0 前言化问题,可知最优解的目标函数一定不小于 5。

为此,在求最优解之前先增加一个约束条件,即过滤0- 1 型整数规划是整数规划的特例,其数学模型的目 条件:3x - 2x +5x !5##⊙ 标函数、约束条件与线性规划相同,不同的是其变量只能1 2 3 过滤条件的作用是:在检验一个解是否为可行解之取 0 和 1,分别表示两种截然相反的结果。

0- 1 型整数规前,先看目标函数是否不小于 5,若小于 5,则肯定不是最 划应用很广,如土木工程系统的最优工程配置问题,城建优解,其可行性无须再检验而直接被淘汰,可以大大减少规划中的居民点、给水点、加油站和商业网点的最优布局计算工作量。

问题,均可应用 0- 1 型整数规划求得最优解。

有了过滤条件,就可以列表计算。

对解集中的解逐个检0- 1 型整数规划的数学模型如下:验,先检验过滤条件,若不符合则直接淘汰该解;若符合条 目标函数:件⊙,再按①~④顺序检验每一个约束条件,当某一个约 束条件不满足时即行淘汰,其右边的约束条件再无检验 约束条件:的必要。

这样,计算工作量可大为减少。

本例中有 3 个变量,共有 23=8 个解需要检验,通过计 算求得的最优解为: .本例以 为初始可行解,通过建立过滤条1 求解 0- 1 型整数规划三种通用的方法 件,只计算了 18 次就找到了最优解,而用穷举法需要计算1.1 穷举法40 次,技术工作量大大减少了。

如在求解过程发现更好的 由于 0- 1 型整数规划的变量个数有限且取值非 0 即可行解及时更换过滤条件 ,计算工作量还可进一步减少。

1,所以不难将解的集合找出来,再检验每个解的可行性, 1.2.2 对隐枚法法 I 的评价 凡符合全部约束条件者均为可行解,通过比较目标函数 对隐枚举法 I 来说其数学模型无须转化为标准型,减的值便可找到最优解,这个解法称为穷举法。

当变量和约 少了人工处理的工作量,但它需要检验的方案较多,而且 束条件很多时,其工作量是非常大的。

运筹学 第三章 0-1规划

运筹学 第三章 0-1规划

例2 求解0-1规划
编号
max z 3 x1 2 x2 5 x3
s.t. x1 2 x2 x3 2

x1 4 x2 x3 2 x1 2 x2 3
② ③
4x2 x3 6

xi 0 or 1, i 1,2,3
算法过程:1. 先找出一个可行解,比如(1,0,0).相应
cnn
称为指派问题 的效益矩阵。

定理:将指派问题的效益矩阵的行(列)分别减去该行(列) 的最小元素,得到的新指派问题和原问题的最优解相同. 意义:根据定理,对指派问题可以化简,使 最优值呢? 得其效益矩阵中每一行至少有一个0元素.
这种简化对于求解有何帮助?
任务 A
B
C
D
人员

2
15
13
4

10
在海淀区,由A6,A7中至少选一个. 假设选用Ai点,设备投资估计为bi元,每年获利估计ci元, 但是总投资额不超过B元。问应该选择哪几个点可以使年 利润最大?
➢分析问题
如图,如何确定选择哪些点?有多少种可能?
试一试
枚举 法
A7
A6
海淀区
共有多少情形?
A5 A4
西城区 专门的解法研究 ——隐枚举法.
安排n个人完成n项工作,使总效率最高的问题称为指 派问题或者分派问题(Assignment problem).
例 甲、乙、丙、丁四人去完成A、B、C、D四项工作. 要求每个人只能完成一项工作,每个工作只能一人完成,
他们所需费用如下表,应如何安排工作,使所需总费用最
少?
任务 A
B
C
D
人员

2
10

0-1规划的隐枚举法

0-1规划的隐枚举法

2013—2014(2)专业课程实践论文题目:0-1规划的隐枚举法一、算法理论 0—1规划在整数规划中占有重要地位,一方面因为许多实际问题,例如指派问题、选地问题、送货问题都可归结为此类规划,另一方面任何有界变量的整数规划都与0-1规划等价,用0—1规划方法还可以把多种非线性规划问题表示成整数规划问题,所以不少人致力于这个方向的研究.求解0—1规划的常用方法是分枝定界法,对各种特殊问题还有一些特殊方法.线性模型中,当变量的取值只能是“0”或“1”时,称之为“0-1规划问题”。

有种极其简单的解法,就是将变量取值为0或1的所有组合列出,然后分别代入目标函数,选出其中能使目标函数最优化的组合,即为最优解。

但是真的这样会做很多无用功,浪费大量资源,所以,需要改进方法.本文主要介绍隐枚举法的应用原理,意在剖析其“隐"在何处.从而帮助读者更好地应用这种方法。

和线性规划问题一样,首先需要将模型标准化。

标准化对0-1规划问题提出四点要求:1。

目标函数为最小优化2.目标函数中变量的系数都为正3。

在目标函数中,变量按系数值从小到大排列,则约束函数中,变量的排列次序也做相应改变。

4.所有变量均为0或10-1线性规划的基本形式是1min nj jj Z c x ==∑011,2,,..1,2,,j ij j j x j m s t a x b i n ==⋅⋅⋅⎧⎪⎨≤=⋅⋅⋅⎪⎩∑或function [intx,intf] = ZeroOneprog(c,A,b,x0)%目标函数系数向量,c%不等式约束矩阵,A%不等式约束右端向量,b%初始整数可行解,x0%目标函数取最小值时的自变量值,intx%目标函数的最小值,intfsz = size(A);if sz(2) < 3[intx,intf] = Allprog(c,A,b);%穷举法else[intx,intf] = Implicitprog(c,A,b,x0); %隐枚举法endfunction [intx,intf] = Allprog(c,A,b)sz_A = size(A);rw = sz_A(1);col = sz_A(2);minf = inf;for i=0:(2^(col)-1) %枚举空间x1 = myDec2Bin(i,col);%十进制转化为二进制if A*x1 >= b %是否满足约束条件f_tmp = c*x1;if f_tmp 〈 minfminf = f_tmp;intx = x1;intf = minf;elsecontinue;endelsecontinue;endendfunction[intx,intf] = Implicitprog(c,A,b,x0)%隐枚举法sz_A = size(A);rw = sz_A(1);col = sz_A(2);minf = c*x0;A = [A;—c];b = [b;-minf];%增加了一个限制分量for i=0:(2^(col)—1)x1 = myDec2Bin(i,col);if A*x1 >= bf_tmp = c*x1;if f_tmp 〈 minfminf = f_tmp;b(rw+1,1) = —minf;%隐枚举法与穷举法的区别在于此句 intx = x1;intf = minf;elsecontinue;endelsecontinue;endendfunction y = myDec2Bin(x,n) %十进制转化为二进制str = dec2bin(x,n);for j=1:ny(j) = str2num(str(j));endy = transpose(y);四、算法实现例1.求解下面0—1规划()⎪⎩⎪⎨⎧=≥++++≥++++++++=105224287453232min 54321543215432154321或,x ,x ,x ,x x x x x x x x x x x x ,s.t.x x x x x x f解:在MATLAB 命令框在输入下列命令:〉〉 c=[1 2 3 1 1];>> A=[2 3 5 4 7;1 1 4 2 2];>〉 b=[8;5];>〉 x0=[1;1;1;1;1];>> [intx,intf]=ZeroOneprog (c ,A,b,x0)所得结果如下:1231231231213123max 3252244..346,,01z x x x x x x x x x s t x x x x x x x =-++-≤⎧⎪++≤⎪⎪+≤⎨⎪+≤⎪⎪⎩为或 解:在MATLAB 命令框在输入下列命令:>> c=[—3,2,—5];〉> A=[—1,—2,1;-1,—4,—1;-1,—1,0;—4,0,-1]; >> b=[-2;-4;—3;-6];〉> x0=[1;0;0];>〉 [intx,intf]=ZeroOneprog (c ,A ,b,x0)123412341234124min 3721648..53501,1,2,3,4j z x x x x x x x x x x x x s t x x x x j =+-+-+-≥⎧⎪-++≥⎪⎨++≥⎪⎪==⎩或 解:在MATLAB 命令框在输入下列命令: >〉 c=[3,7,-1,1];A=[2,-1,1,-1;1,—1,6,4;5,3,0,1]; b=[1;8;5];>> x0=[1;1;1;1];〉〉 [intx,intf]=ZeroOneprog (c,A,b ,x0)123123123123max 62323352..2401,1,2,3j z x x x x x x x x x s t x x x x j =++++≤⎧⎪-+≥⎪⎨++≤⎪⎪==⎩或解:在MATLAB 命令框在输入下列命令: 〉> c=[-6,—2,-3];A=[-1,-2,—1;3,—5,1;—2,-1,—1]; b=[-3;2;-4];x0=[1;0;0];[intx ,intf ]=ZeroOneprog (c ,A ,b,x0)。

0-1型整数规划的一般解法---隐枚举法解

0-1型整数规划的一般解法---隐枚举法解
若某人可做几件事,则将该人化作相同的几个“人”来接受指派,且费用系数取值 相同。
例如:丙可以同时任职A和C工作,求最优指派方案。
甲 15 20 10 9

6
5
4
7
丙 10 13 16 17
15 20 10 9
6
5
4
7
10 13 16 17
10 13 16 17
指派问题与匈牙利法
4. 某事一定不能由某人做的指派问题
变,得到新的系数矩阵。
3 Ø0 2 4 Ø0 √
◎0 3 3 Ø0 5
√√

指派问题与匈牙利法
0Ø ◎0 3 0Ø 3
1
6
0◎ 2
Ø0
3 2 0Ø 0◎ 3
2
Ø0
2
◎0 4 4
3
◎0
0Ø 6
总费用为 =5+7+6+6+4=28
注:此问题有多个最优解
指派问题与匈牙利法
Ø0 Ø0 3 ◎0 3
3
◎0
选择直线外的最小元素 为1;直线外元素减1, 直线交点元素加1,其
4 1 ◎0 1 3
他保持不变。
4
Ø0
3
5
1

◎0 2 3 0Ø 5

指派问题与匈牙利法
1 ◎0 3 1 3 √
2
6
Ø0
3
0◎

l =m=4 < n=5
选择直线外最小元素为1, 直线外元素减1,直线交
4 2 ◎0 1 3 √ 点元素加1,其他保持不
指派问题与匈牙利法
用匈牙利法求出最优指派方案为:

隐枚举法的定义

隐枚举法的定义

隐枚举法
一种特殊的分支定界法.对0-1规划问题.利用变量只能取0或1的两个值的特性,进行分支定界,以达到隐枚举的目的.基本思路是:通过变量的变换,使目标函数中的系数全为非正.首先令全部变量取0,因为目标函数的系数全非正,所以此解相应的目标函数值s=0就是上界.若可行,则此解为最优解,计算终止.否则,有选择地指定其中某个变量为0或1,并把它们固定下来(称为固定变量),将问题分解成两个子问题.然后,分别对它们进行检验,即对未被固定取值的变量(称为自由变量),令其全部为0,检查它们与固定变量所组成的解是否可行.若可行,则此解就是目前最好的可行解(不一定是最优解),不再分支,其相应的目标函数值就是原问题的一个下界;否则,在余下的自由变量中,继续上面的过程.经过检验,或者停止分支,修改下界,或者有选择地将某个自由变量转为固定变量,指定其为0或1,把子问题再分支.如此进行下去,直到全部子问题停止分支,或没有自由变量为止,而以其中最大的下界值所对应的可行解为最优解.。

0—1型整数规划问题的求解方法

0—1型整数规划问题的求解方法

0—1型整数规划问题的求解方法1、一般来说,碰到了0-1规划的问题,怎么办?枚举,比较每个解对应的目标函数值。

为什么要枚举,是把每一个解都拿出来比较。

因此,有的叫法是显枚举法?2、有显枚举法,就有隐枚举法。

如果说,显枚举法是显式的枚举法,那么隐枚举法就是隐式的枚举法。

都是枚举法,都是要把所有的解带入到目标函数进行比较,对不对?理论上是这样的,可以参考其他的讲解。

但是,其他的地方讲解似乎没有把这个讲解到位,为什么叫隐枚举法。

有一种说法是:设计一种方法,只检查0-1变量组合的一部分,就能得到问题的最优解。

3、首先,如果你不把所有的解都判断一下,我怎么知道那个解是不是最优的解呢?回顾一下LP问题的求解,发现线性规划并不需要判断所有的解,确切的说,是所有的可行解。

只需要在所有的基本可行解里面去寻找最优的解。

因此,0-1规划求解的思路也是一样,是在所有的0-1可行解里面去寻找。

这样,就需要在约束条件里面去一个一个的判断,这个0-1组合是否可行。

所以,隐枚举法的思路,还是枚举法,但是我并不是要把每个解都要进行约束条件的判断,判断他是不是可行,可以只检查所有0-1变量组合的一部分约束条件的判断,这样还是可以得到问题的最优解。

4、接着,那怎么减少约束条件的检查判断呢?设置一个过滤条件,叫做过滤约束,如果这个不满足,那么其他的约束就不用判断了。

因此,隐的意思应该在这里。

问题来了,怎么添加这个过滤约束呢?通过一种方法(试探法),找到一个可行解,然后代入目标函数,得到目标值,这个就得到了一个过滤约束。

求最大值的时候,如果一个可行解的目标值不大于这个约束,那么直接排除。

5、继续。

怎么得到这个过滤约束。

比如下面的例子:一种说法是试探法,随便试探?或者可以从某一个解开始(比如0,0,0)开始递增,直到得到一个可行解,然后就得到了这个过滤约束了,比如上面的例子,我们可以从1,0,0开始递增,先看看这个解是不是可行解。

是在可行解,因此看目标函数值是3,因此得到一个约束,3x1-2x2+5x3>=3过滤约束。

0—1型整数规划问题的求解方法

0—1型整数规划问题的求解方法

0—1型整数规划问题的求解方法0-1型整数规划问题是一类特殊的整数规划问题,其中变量只能取0或1,即变量是二进制的。

这类问题在实际应用中具有广泛的应用,如装配线平衡、员工调度、货物装载等。

求解0-1型整数规划问题可以使用多种方法,下面将介绍几种常用的方法。

1.枚举法:枚举法是最朴素的解法,它列举出了所有可能解,并通过穷举所有解的方式找到最优解。

这种方法适用于问题规模较小且没有明显的约束条件,但对于大规模问题不适用。

2.分支定界法:分支定界法是一种广泛应用于整数规划的方法。

它从原问题形成一个目标函数较小的松弛问题开始,通过分支操作将问题分解为一系列子问题,每次选择一个变量分支,并根据问题的特性设置相应的约束条件。

通过逐步分解问题,最终获得最优解。

3.动态规划法:动态规划法通过构建状态转移方程的方式,将问题分解为多个子问题,并利用子问题之间的关系求解最优解。

对于0-1型整数规划问题,可以使用动态规划来解决。

首先定义一个二维数组dp[i][j],其中dp[i][j]表示在前i个物品中选择一些物品放入背包容量为j的情况下的最大价值。

然后根据背包容量逐步求解,最后得到最优解。

4.启发式算法:启发式算法是一类基于经验和直觉的算法,通过评估当前解的优劣性来寻找最优解。

对于0-1型整数规划问题,可以使用启发式算法如遗传算法、模拟退火算法、粒子群算法等进行求解。

这些算法通过随机和逐步优化的方式,可以在较短时间内找到较好的解。

以上是常用的几种0-1型整数规划问题的求解方法,根据问题的规模、约束条件和求解的要求选择合适的方法。

在实际应用中,通常会根据问题的特性选择相应的算法,并结合数学模型和计算机编程进行求解。

0–1型整数规划的解法

0–1型整数规划的解法

0–1型整数规划的解法
解0-1 型整数规划最容易想到的方法,和一般整数规划的情形一样,就是穷举法,即检查变量取值为0 或1 的每一种组合,比较目标函数值以求得最优解,这就需要检查变量取值的2的n次方个组合。

对于变量个数n 较大(例如
n>100),这几乎是不可能的。

因此常设计一些方法,只检查变量取值的组合的一部分,就能求到问题的最优解。

这样的方法称为隐枚举法(implicit enumeration ),分枝定界法也是一种隐枚举法。

当然,对有些问题隐枚举法并不适用,所以有时穷举法还是必要的。

下面举例说明一种解0-1 型整数规划的隐枚举法。

求解思路及改进措施:
(i )先试探性求一个可行解,易看出满足约束条件,故为一
个可行解,且z=3。

(ii )因为是求极大值问题,故求最优解时,凡是目标值z<3 的解不必检验是否满足约束条件即可删除,因它肯定不是最优解,于是应增加一个约束条件(目标值下界).
(iii )改进过滤条件。

(iv )由于对每个组合首先计算目标值以验证过滤条件,故应优先计算目标值z 大的组合,这样可提前抬高过滤门槛,以减少计算量。

谈隐枚举法中过滤约束的使用与解题技巧

谈隐枚举法中过滤约束的使用与解题技巧

谈隐枚举法中过滤约束的使用与解题技巧吴振华;贵文龙;智国建【摘要】First, an example for solving steps and problem-solving skills, "0-1 integer programming" in the implicit enumeration method, focusing onthe structure and select the filter constraints. Then, by comparing the sequence of the two solutions, indicating the role of the filter constraints and the meaning of "hidden" word. Finally, after analyzing the causes of common errors in the problem solving process, summed using implicit enumeration Notes: Solving the order determined in accordance with the objective function; filtering constraint must satisfy theconstraints;reasonable choice of filter constraints;avoid solutions portfolio omissions.%首先,举例说明“0-1整数规划”中隐枚举法的求解步骤和解题技巧,重点阐述过滤约束的构造和选择。

然后,通过对两种求解顺序的比较,说明过滤约束的作用以及“隐”字的含义;最后,在分析解题过程中常见错误的原因之后,总结出使用隐枚举法的注意事项:根据目标函数确定求解顺序;过滤约束必须满足约束条件;合理选择过滤约束;避免解组合的遗漏。

运筹学匈牙利法

运筹学匈牙利法

满足约束条件(是∨ 否×) (1) (2) (3) (4)
过滤 条件
√√√ √ 0
√√√ √ 5
-2
3
3
√√√ √ 8
1
6
max Z 3 x 1 2 x 2 5 x 3
x 1 2 x 2 x 3 2 (1)
x1 x1
4
x2 x2
x3
4 3
(2) (3)
4 x 2 x 3 6 (4)
1 0 7
0 4 1
4
3
0 √

找(1到)对3没个有独独立立零零元元素素,的但行m打√= 号3 <;n = 4 (2)对已打√号的行中所有含划掉零元素的列打√号;
(3)再对打有√号的列中含独立零元素的行打√号;
(4)重复(2),(3)直到得不出新的打√号的行、列为止;
(5)对没有打√号的行画横线,有打√号的列画纵线,这就 得到覆盖所有零元素的最少直线数
xij
n
0不分配i个 第人取完j成 项第 任务
x ij 1
( i 1 .2 . .n )
j1
n
x ij 1 ( j 1 . 2 . . n )
i1
x ij 0 或 1( i , j 1 . 2 . . n )
典型问题
例1:有一份说明书,要分别译成英、日、 德、俄四种文字,交与甲、乙、丙、丁四个 人去完成,因各人专长不同,他们完成翻译 不同文字所需要的时间(小时)如表所示。 规定每项工作只能交与其中的一个人完成, 每个人只能完成其中的一项工作。
工作 人 甲 乙 丙 丁
译英文 译日文 译德文 译俄文
2 10 15 4 13 14 4 15
97 14 8 16 11 13 9

隐枚举法的定义

隐枚举法的定义

隐枚举法
一种特殊的分支定界法.对0-1规划问题.利用变量只能取0或1的两个值的特性,进行分支定界,以达到隐枚举的目的.基本思路是:通过变量的变换,使目标函数中的系数全为非正.首先令全部变量取0,因为目标函数的系数全非正,所以此解相应的目标函数值s=0就是上界.若可行,则此解为最优解,计算终止.否则,有选择地指定其中某个变量为0或1,并把它们固定下来(称为固定变量),将问题分解成两个子问题.然后,分别对它们进行检验,即对未被固定取值的变量(称为自由变量),令其全部为0,检查它们与固定变量所组成的解是否可行.若可行,则此解就是目前最好的可行解(不一定是最优解),不再分支,其相应的目标函数值就是原问题的一个下界;否则,在余下的自由变量中,继续上面的过程.经过检验,或者停止分支,修改下界,或者有选择地将某个自由变量转为固定变量,指定其为0或1,把子问题再分支.如此进行下去,直到全部子问题停止分支,或没有自由变量为止,而以其中最大的下界值所对应的可行解为最优解.。

0-1规划与指派问题

0-1规划与指派问题

(i=1,2,···,m) (j=1,2,···,m)
xij =0或1 (i=1,2,···,m; j=1,2,···,m)
解法
一、匈牙利方法
由匈牙利数学家Konig提出。
思路:克尼格定理(konig)
如果从效率矩阵[aij]的每一行元素中 分别减去(或加上)一个常数ui,从每一列中 分别减去(或加上)一个常数vj,得到一个新 的效率矩阵[bij],其中bij=aij-ui-vj,则以[bij] 为效率矩阵的最优解等价于以[aij]为效率 矩阵的最优解.
最大化指派问题
1 3 0 11 8 0 0 1 1 2 0 1 2 1 0 1 0 5 0 4 1 2 3 4 0
Variants of Assignment Problem 指派问题的变形
指派问题的变形: ▪任务比被指派者多 ▪被指派者比要完成的任务多 ▪有一些被指派者并不能进行某一些的任务 ▪每个被指派者可以同时被指派给多于一个的任务 ▪每一项任务都可以由多个被指派者共同完成
B)从第一列开始,若只有一个0,则记(0), 同时作直线覆盖该行的元素。否则,转下列;
C)重复A)、B),至再找不出这样的0元素, 转D)
D)可能出现以下情况: ① 每行均有(0)元素,则在有(0)位置构成最 优解中xij=1; ② 所有0元素均有直线覆盖,但记(0)的个数<m
个,转⑶。
③多于两行和两列存在未被直线覆盖的0元素,即
设 xj=
1 0
--- 选择开采第j个构造 ---不选择开采第j个构造
10
max z=Σj=c1jxj
-----年总收益
10
j∑=1ajxj b
----投资额限制
xj=0或1 (j=1,2,---,10)

0-1整数规划隐枚举法代码 (直接复制及可运行)

0-1整数规划隐枚举法代码  (直接复制及可运行)

华北电力大学数理系邵森using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace zhengshuguihuayinmeijufa{public class Program{public static int Min(int[] V){int min = V[0];for (int i = 0; i < V.Length-1 ; i++)for (int j = 1; j < V.Length ; j++){if (min > V[j])min = V[j];}return min;}public static int Max(int[] V){int max = V[0];for (int i = 0; i < V.Length - 1; i++)for (int j = 1; j < V.Length; j++){if (max<V[j])max = V[j];}return max;}public static int PaiDing(int [,] T,int a, int b, int c,int d,int e,int f,int g,int t,int L,int H,int U,int []M) {if (U == 3){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] <= T[i, 3]))m++;}if (m == H )t = a * M[0] + b * M[1] + c * M[2];}if (U == 4){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] <= T[i, 4]))m++;}if (m == H )t = a * M[0] + b * M[1] + c * M[2] + d * M[3];}if (U == 5){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] +d* T[i, 3]+e*T[i,4]<=T[i,5]))m++;}if (m == H )t = a*M[0]+b*M[1]+c*M[2]+d*M[3]+e*M[4];}if (U == 6){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] + e * T[i, 4] +f*T[i, 5]<=T[i,6]))m++;}if (m == H )t = a*M[0]+b*M[1]+c*M[2]+d*M[3]+e*M[4]+f*M[5];}if (U == 7){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] + e * T[i, 4] + f * T[i, 5] +g*T[i, 6]<=T[i,7]))m++;}if (m == H)t = a*M[0]+b*M[1]+c*M[2]+d*M[3]+e*M[4]+f*M[5]+g*M[6];}return t;}public static int PaiDing1(int[,] T, int a, int b, int c, int d, int e, int f, int g, int t, int L, int H, int U, int[] M){if (U == 3){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] >= T[i, 3]))m++;}if (m == H)t = a * M[0] + b * M[1] + c * M[2];elset = t + 10000;}if (U == 4){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] >= T[i, 4]))m++;}if (m == H)t = a * M[0] + b * M[1] + c * M[2] + d * M[3];elset = t + 10000;}if (U == 5){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] + e * T[i, 4] >= T[i, 5]))m++;}if (m == H)t = a * M[0] + b * M[1] + c * M[2] + d * M[3] + e * M[4];elset = t + 10000;}if (U == 6){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] + e * T[i, 4] + f * T[i, 5] >= T[i, 6]))m++;}if (m == H)t = a * M[0] + b * M[1] + c * M[2] + d * M[3] + e * M[4] + f * M[5];elset = t + 10000;}if (U == 7){int m = 0;for (int i = 0; i < H; i++){int j = 0;if ((a * T[i, j] + b * T[i, j + 1] + c * T[i, j + 2] + d * T[i, 3] + e * T[i, 4] + f * T[i, 5] + g * T[i, 6] >=T[i, 7]))m++;}if (m == H)t = a * M[0] + b * M[1] + c * M[2] + d * M[3] + e * M[4] + f * M[5] + g * M[6];elset = t + 10000;}return t;}public static string FH(int[,] T, int[] M, int U, int Z, int L, int H,string str)//T为a传ä?入¨?的Ì?矩?阵¨®V为a记?录?所¨´求¨®解a的Ì?值¦ÌM目?标À¨º函¡¥数ºy的Ì?数ºy组Á¨¦//U变À?元a的Ì?个?数ºyZ为a最Á?优®?值¦Ì{if (U == 3){int N = 8;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "000";K[1] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[1] = "001";K[2] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[2] = "010";str1[3] = "011";str1[4] = "100";K[3] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[5] = "101";K[4] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[6] = "110";K[5] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[7] = "111";K[6] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[7] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);Z = Max(K);int j=0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 4){int N = 16;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "0000";K[1] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[1] = "0001";K[2] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[2] = "0010";K[3] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[3] = "0011";K[4] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[4] = "0100";K[5] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[5] = "0101";K[6] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[6] = "0110";K[7] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[7] = "0111";K[8] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "1000";K[9] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[9] = "1001";K[10] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[10] = "1010";K[11] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[11] = "1011";K[12] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[12] = "1100";K[13] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[13] = "1101";K[14] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[14] = "1110";K[15] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[15] = "1111";Z = Max(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 5){int N = 32;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "00000";K[1] = PaiDing(T, 0, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[1] = "00001";K[2] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[2] = "00010";K[3] = PaiDing(T, 0, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[3] = "00011";K[4] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[4] = "00100";K[5] = PaiDing(T, 0, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[5] = "00101";K[6] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[6] = "00110";K[7] = PaiDing(T, 0, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[7] = "00111";K[8] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "01000";K[9] = PaiDing(T, 0, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[9] = "01001";K[10] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[10] = "01010";K[11] = PaiDing(T, 0, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[11] = "01011";K[12] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[12] = "01100";K[13] = PaiDing(T, 0, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[13] = "01101";K[14] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[14] = "01110";K[15] = PaiDing(T, 0, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[15] = "01111";K[16] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[16] = "10000";K[17] = PaiDing(T, 1, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[17] = "10001";K[18] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[18] = "10010";K[19] = PaiDing(T, 1, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[19] = "10011";K[20] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[20] = "10100";K[21] = PaiDing(T, 1, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[21] = "10101";K[22] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[22] = "10110";K[23] = PaiDing(T, 1, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[23] = "10111";K[24] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[24] = "11000";K[25] = PaiDing(T, 1, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[25] = "11001";K[26] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[26] = "11010";K[27] = PaiDing(T, 1, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[27] = "11011";K[28] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[28] = "11100";K[29] = PaiDing(T, 1, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[29] = "11101";K[30] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[30] = "11110";K[31] = PaiDing(T, 1, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[31] = "11111";Z = Max(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 6){int N = 64;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "000000";K[1] = PaiDing(T, 0, 0, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[1] = "000001";K[2] = PaiDing(T, 0, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[2] = "000010";K[3] = PaiDing(T, 0, 0, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[3] = "000011";K[4] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[4] = "000100";K[5] = PaiDing(T, 0, 0, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[5] = "000101";K[6] = PaiDing(T, 0, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[6] = "000110";K[7] = PaiDing(T, 0, 0, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[7] = "000111"; K[8] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "001000"; K[9] = PaiDing(T, 0, 0, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[9] = "001001"; K[10] = PaiDing(T, 0, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[10] = "001010"; K[11] = PaiDing(T, 0, 0, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[11] = "001011"; K[12] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[12] = "001100"; K[13] = PaiDing(T, 0, 0, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[13] = "001101"; K[14] = PaiDing(T, 0, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[14] = "001110"; K[15] = PaiDing(T, 0, 0, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[15] = "001111"; K[16] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[16] = "010000"; K[17] = PaiDing(T, 0, 1, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[17] = "010001"; K[18] = PaiDing(T, 0, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[18] = "010010"; K[19] = PaiDing(T, 0, 1, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[19] = "010011"; K[20] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[20] = "010100"; K[21] = PaiDing(T, 0, 1, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[21] = "010101"; K[22] = PaiDing(T, 0, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[22] = "010110"; K[23] = PaiDing(T, 0, 1, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[23] = "010111"; K[24] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[24] = "011000"; K[25] = PaiDing(T, 0, 1, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[25] = "011001"; K[26] = PaiDing(T, 0, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[26] = "011010"; K[27] = PaiDing(T, 0, 1, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[27] = "011011"; K[28] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[28] = "011100"; K[29] = PaiDing(T, 0, 1, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[29] = "011101"; K[30] = PaiDing(T, 0, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[30] = "011110"; K[31] = PaiDing(T, 0, 1, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[31] = "011111"; K[32] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[32] = "100000"; K[33] = PaiDing(T, 1, 0, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[33] = "100001"; K[34] = PaiDing(T, 1, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[34] = "100010"; K[35] = PaiDing(T, 1, 0, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[35] = "100011"; K[36] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[36] = "100100"; K[37] = PaiDing(T, 1, 0, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[37] = "100101"; K[38] = PaiDing(T, 1, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[38] = "100110"; K[39] = PaiDing(T, 1, 0, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[39] = "100111"; K[40] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[40] = "101000"; K[41] = PaiDing(T, 1, 0, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[41] = "101001"; K[42] = PaiDing(T, 1, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[42] = "101010"; K[43] = PaiDing(T, 1, 0, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[43] = "101011"; K[44] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[44] = "101100"; K[45] = PaiDing(T, 1, 0, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[45] = "101101"; K[46] = PaiDing(T, 1, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[46] = "101110"; K[47] = PaiDing(T, 1, 0, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[47] = "101111"; K[48] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[48] = "110000"; K[49] = PaiDing(T, 1, 1, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[49] = "110001"; K[50] = PaiDing(T, 1, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[50] = "110010"; K[51] = PaiDing(T, 1, 1, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[51] = "110011"; K[52] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[52] = "110100"; K[53] = PaiDing(T, 1, 1, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[53] = "110101"; K[54] = PaiDing(T, 1, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[54] = "110110"; K[55] = PaiDing(T, 1, 1, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[55] = "110111"; K[56] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[56] = "111000"; K[57] = PaiDing(T, 1, 1, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[57] = "111001"; K[58] = PaiDing(T, 1, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[58] = "111010"; K[59] = PaiDing(T, 1, 1, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[59] = "111011"; K[60] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[60] = "111100"; K[61] = PaiDing(T, 1, 1, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[61] = "111101"; K[62] = PaiDing(T, 1, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[62] = "111110"; K[63] = PaiDing(T, 1, 1, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[63] = "111111"; Z = Max(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}return str;}public static string FH1(int[,] T, int[] M, int U, int Z, int L, int H, string str)//T为a传ä?入¨?的Ì?矩?阵¨®V为a记?录?所¨´求¨®解a的Ì?值¦ÌM目?标À¨º函¡¥数ºy的Ì?数ºy组Á¨¦//U变À?元a的Ì?个?数ºyZ为a最Á?优®?值¦Ì{if (U == 3){int N = 8;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "000";K[1] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[1] = "001";K[2] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[2] = "010";str1[3] = "011";str1[4] = "100";K[3] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[5] = "101";K[4] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[6] = "110";K[5] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[7] = "111";K[6] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[7] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);Z = Min(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 4){int N = 16;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "0000";K[1] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[1] = "0001";K[2] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[2] = "0010";K[3] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[3] = "0011";K[4] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[4] = "0100";K[5] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[5] = "0101";K[6] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[6] = "0110";K[7] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[7] = "0111";K[8] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "1000";K[9] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[9] = "1001";K[10] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[10] = "1010";K[11] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[11] = "1011";K[12] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[12] = "1100";K[13] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[13] = "1101";K[14] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[14] = "1110";K[15] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[15] = "1111";Z = Min(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 5){int N = 32;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "00000";K[1] = PaiDing(T, 0, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[1] = "00001";K[2] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[2] = "00010";K[3] = PaiDing(T, 0, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[3] = "00011";K[4] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[4] = "00100";K[5] = PaiDing(T, 0, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[5] = "00101";K[6] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[6] = "00110";K[7] = PaiDing(T, 0, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[7] = "00111";K[8] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "01000";K[9] = PaiDing(T, 0, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[9] = "01001";K[10] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[10] = "01010";K[11] = PaiDing(T, 0, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[11] = "01011";K[12] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[12] = "01100";K[13] = PaiDing(T, 0, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[13] = "01101";K[14] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[14] = "01110";K[15] = PaiDing(T, 0, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[15] = "01111";K[16] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[16] = "10000";K[17] = PaiDing(T, 1, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[17] = "10001";K[18] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[18] = "10010";K[19] = PaiDing(T, 1, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[19] = "10011";K[20] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[20] = "10100";K[21] = PaiDing(T, 1, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[21] = "10101";K[22] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[22] = "10110";K[23] = PaiDing(T, 1, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[23] = "10111";K[24] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[24] = "11000";K[25] = PaiDing(T, 1, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[25] = "11001";K[26] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[26] = "11010";K[27] = PaiDing(T, 1, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[27] = "11011";K[28] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[28] = "11100";K[29] = PaiDing(T, 1, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[29] = "11101";K[30] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[30] = "11110";K[31] = PaiDing(T, 1, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[31] = "11111";Z = Min(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}if (U == 6){int N = 64;int[] K = new int[N];string[] str1 = new string[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[0] = "000000"; K[1] = PaiDing(T, 0, 0, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[1] = "000001"; K[2] = PaiDing(T, 0, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[2] = "000010"; K[3] = PaiDing(T, 0, 0, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[3] = "000011"; K[4] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[4] = "000100"; K[5] = PaiDing(T, 0, 0, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[5] = "000101"; K[6] = PaiDing(T, 0, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[6] = "000110"; K[7] = PaiDing(T, 0, 0, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[7] = "000111"; K[8] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[8] = "001000"; K[9] = PaiDing(T, 0, 0, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[9] = "001001"; K[10] = PaiDing(T, 0, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[10] = "001010"; K[11] = PaiDing(T, 0, 0, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[11] = "001011"; K[12] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[12] = "001100"; K[13] = PaiDing(T, 0, 0, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[13] = "001101"; K[14] = PaiDing(T, 0, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[14] = "001110"; K[15] = PaiDing(T, 0, 0, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[15] = "001111"; K[16] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[16] = "010000"; K[17] = PaiDing(T, 0, 1, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[17] = "010001"; K[18] = PaiDing(T, 0, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[18] = "010010"; K[19] = PaiDing(T, 0, 1, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[19] = "010011"; K[20] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[20] = "010100"; K[21] = PaiDing(T, 0, 1, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[21] = "010101"; K[22] = PaiDing(T, 0, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[22] = "010110"; K[23] = PaiDing(T, 0, 1, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[23] = "010111"; K[24] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[24] = "011000"; K[25] = PaiDing(T, 0, 1, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[25] = "011001"; K[26] = PaiDing(T, 0, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[26] = "011010"; K[27] = PaiDing(T, 0, 1, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[27] = "011011"; K[28] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[28] = "011100"; K[29] = PaiDing(T, 0, 1, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[29] = "011101"; K[30] = PaiDing(T, 0, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[30] = "011110"; K[31] = PaiDing(T, 0, 1, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[31] = "011111"; K[32] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[32] = "100000"; K[33] = PaiDing(T, 1, 0, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[33] = "100001"; K[34] = PaiDing(T, 1, 0, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[34] = "100010"; K[35] = PaiDing(T, 1, 0, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[35] = "100011"; K[36] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[36] = "100100"; K[37] = PaiDing(T, 1, 0, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[37] = "100101"; K[38] = PaiDing(T, 1, 0, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[38] = "100110"; K[39] = PaiDing(T, 1, 0, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[39] = "100111"; K[40] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[40] = "101000"; K[41] = PaiDing(T, 1, 0, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[41] = "101001"; K[42] = PaiDing(T, 1, 0, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[42] = "101010"; K[43] = PaiDing(T, 1, 0, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[43] = "101011"; K[44] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[44] = "101100"; K[45] = PaiDing(T, 1, 0, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[45] = "101101"; K[46] = PaiDing(T, 1, 0, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[46] = "101110"; K[47] = PaiDing(T, 1, 0, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[47] = "101111"; K[48] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M); str1[48] = "110000"; K[49] = PaiDing(T, 1, 1, 0, 0, 0, 1, 0, 0, L, H, U, M); str1[49] = "110001"; K[50] = PaiDing(T, 1, 1, 0, 0, 1, 0, 0, 0, L, H, U, M); str1[50] = "110010"; K[51] = PaiDing(T, 1, 1, 0, 0, 1, 1, 0, 0, L, H, U, M); str1[51] = "110011"; K[52] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M); str1[52] = "110100"; K[53] = PaiDing(T, 1, 1, 0, 1, 0, 1, 0, 0, L, H, U, M); str1[53] = "110101"; K[54] = PaiDing(T, 1, 1, 0, 1, 1, 0, 0, 0, L, H, U, M); str1[54] = "110110"; K[55] = PaiDing(T, 1, 1, 0, 1, 1, 1, 0, 0, L, H, U, M); str1[55] = "110111"; K[56] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M); str1[56] = "111000"; K[57] = PaiDing(T, 1, 1, 1, 0, 0, 1, 0, 0, L, H, U, M); str1[57] = "111001";K[58] = PaiDing(T, 1, 1, 1, 0, 1, 0, 0, 0, L, H, U, M); str1[58] = "111010";K[59] = PaiDing(T, 1, 1, 1, 0, 1, 1, 0, 0, L, H, U, M); str1[59] = "111011";K[60] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M); str1[60] = "111100";K[61] = PaiDing(T, 1, 1, 1, 1, 0, 1, 0, 0, L, H, U, M); str1[61] = "111101";K[62] = PaiDing(T, 1, 1, 1, 1, 1, 0, 0, 0, L, H, U, M); str1[62] = "111110";K[63] = PaiDing(T, 1, 1, 1, 1, 1, 1, 0, 0, L, H, U, M); str1[63] = "111111";Z = Min(K);int j = 0;for (int i = 0; i < N; i++){if (K[i] == Z)j = i;}str = str1[j];}return str;}public static int YM(int[,] T, int[] M, int U,int Z, int L,int H)//T为a传ä?入¨?的Ì?矩?阵¨®V为a记?录?所¨´求¨®解a的Ì?值¦ÌM目?标À¨º函¡¥数ºy的Ì?数ºy组Á¨¦//U变À?元a的Ì?个?数ºyZ为a最Á?优®?值¦Ì{if(U==3){int N = 8;int[] K = new int[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M);K[1] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M);K[2] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[3] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);K[4] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M);K[5] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M);K[6] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[7] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);Z = Max(K);}if (U == 4){int N = 16;int[] K = new int[N];K[0] = PaiDing(T, 0, 0, 0, 0, 0, 0, 0, 0, L, H, U, M);K[1] = PaiDing(T, 0, 0, 0, 1, 0, 0, 0, 0, L, H, U, M);K[2] = PaiDing(T, 0, 0, 1, 0, 0, 0, 0, 0, L, H, U, M);K[3] = PaiDing(T, 0, 0, 1, 1, 0, 0, 0, 0, L, H, U, M);K[4] = PaiDing(T, 0, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[5] = PaiDing(T, 0, 1, 0, 1, 0, 0, 0, 0, L, H, U, M);K[6] = PaiDing(T, 0, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);K[7] = PaiDing(T, 0, 1, 1, 1, 0, 0, 0, 0, L, H, U, M);K[8] = PaiDing(T, 1, 0, 0, 0, 0, 0, 0, 0, L, H, U, M);K[9] = PaiDing(T, 1, 0, 0, 1, 0, 0, 0, 0, L, H, U, M);K[10] = PaiDing(T, 1, 0, 1, 0, 0, 0, 0, 0, L, H, U, M);K[11] = PaiDing(T, 1, 0, 1, 1, 0, 0, 0, 0, L, H, U, M);K[12] = PaiDing(T, 1, 1, 0, 0, 0, 0, 0, 0, L, H, U, M);K[13] = PaiDing(T, 1, 1, 0, 1, 0, 0, 0, 0, L, H, U, M);K[14] = PaiDing(T, 1, 1, 1, 0, 0, 0, 0, 0, L, H, U, M);K[15] = PaiDing(T, 1, 1, 1, 1, 0, 0, 0, 0, L, H, U, M);Z = Max(K);}。

运筹学中国大学mooc课后章节答案期末考试题库2023年

运筹学中国大学mooc课后章节答案期末考试题库2023年

运筹学中国大学mooc课后章节答案期末考试题库2023年1.如果在运输问题或转运问题模型中,Cij都是从产地i到产地j的最小运输费用,则运输问题同转运问题都将得到相同的最优解参考答案:正确2.在求解整数规划问题时,不可能出现的是参考答案:无穷多最优解3.下列那种办法可以求解指派问题参考答案:匈牙利法4.0-1规划的隐枚举法是分支定界的特例。

参考答案:正确5.匈牙利法可以直接求解极大化的指派问题。

参考答案:错误6.整数规划中,通过增加线性约束条件将原规划可行域进行切割,切割后的可行域的整数解正好是原规划的最优解的方法是参考答案:割平面法7.整数问题的可行解一定是它松弛问题的可行解,反之则不一定成立。

参考答案:正确8.求指派问题的匈牙利方法要求系数矩阵中每个元素都是参考答案:非负的9.运输问题一定有最优解参考答案:正确10.产地个数为m,销地个数为n的平衡运输问题的对偶问题有【图片】个约束参考答案:正确11.在运输问题中,调整对象的确定应选择参考答案:检验数为负且绝对值最大12.在解决运筹学问题时,根据对问题内在机理的认识直接构造出模型的方法称为:参考答案:直接分析法13.当迭代到运输问题的最优解时,如果有某非基变量的检验数等于零,则说明该运输有()参考答案:多重最优解14.运筹学是一门在第一次世界大战期间发展起来的新兴科学参考答案:错误15.用割平面求纯整数规划时,要求包括松弛变量在内的全部变量都取整数。

参考答案:正确16.用分支定界法求一个极大化的整数规划时,当得到多于一个可行解时,通常可以任取一个作为下界值,在进行比较和剪枝。

参考答案:错误17.模型是对各种变量关系的描述,是解决问题的关键参考答案:正确18.运输问题的解有四种情况:分别为:唯一最优解、无穷多最优解、无界解、无可行解。

参考答案:错误19.人工变量一旦出基就不会再进基参考答案:正确20.用匈牙利法求解指派问题时,不可以进行的操作是参考答案:效益矩阵乘以一个常数21.X是线性规划的基本可行解则有参考答案:X中的基变量非负,非基变量为零22.整数规划的最优解中,决策变量满足什么条件参考答案:决策变量必须都是整数23.运筹学具有多学科交叉的特点参考答案:正确24.下例错误的结论是参考答案:检验数就是目标函数的系数25.若线性规划问题存在可行域,则可行域一定包含坐标的原点参考答案:错误26.线性规划具有唯一最优解是指参考答案:最优表中非基变量检验数全部非零27.标准指派问题(m人,m件事)的规划模型中,有()个决策变量。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

2013-2014(2)专业课程实践论文题目:0-1规划的隐枚举法
一、算法理论 0—1规划在整数规划中占有重要地位,一方面因为许多实际问题,例如指派问题、选地问题、送货问题都可归结为此类规划,另一方面任何有界变量的整数规划都与0—1规划等价,用0—1规划方法还可以把多种非线性规划问题表示成整数规划问题,所以不少人致力于这个方向的研究。

求解0—1规划的常用方法是分枝定界法,对各种特殊问题还有一些特殊方法。

线性模型中,当变量的取值只能是“0”或“1”时,称之为“0-1规划问题”。

有种极其简单的解法,就是将变量取值为0或1的所有组合列出,然后分别代入目标函数,选出其中能使目标函数最优化的组合,即为最优解。

但是真的这样会做很多无用功,浪费大量资源,所以,需要改进方法。

本文主要介绍隐枚举法的应用原理,意在剖析其“隐”在何处。

从而帮助读者更好地应用这种方法。

和线性规划问题一样,首先需要将模型标准化。

标准化对0-1规划问题提出四点要求:
1.目标函数为最小优化
2.目标函数中变量的系数都为正
3.在目标函数中,变量按系数值从小到大排列,则约束函数中,变量的排列次序也做相应改变。

4.所有变量均为0或1
0-1线性规划的基本形式是
1
min n
j j
j Z c x ==∑
011,2,,..1,2,,j ij j j x j m s t a x b i n ==⋅⋅⋅⎧⎪⎨≤=⋅⋅⋅⎪⎩∑或
function [intx,intf] = ZeroOneprog(c,A,b,x0)
%目标函数系数向量,c
%不等式约束矩阵,A
%不等式约束右端向量,b
%初始整数可行解,x0
%目标函数取最小值时的自变量值,intx
%目标函数的最小值,intf
sz = size(A);
if sz(2) < 3
[intx,intf] = Allprog(c,A,b); %穷举法
else
[intx,intf] = Implicitprog(c,A,b,x0); %隐枚举法end
function [intx,intf] = Allprog(c,A,b)
sz_A = size(A);
rw = sz_A(1);
col = sz_A(2);
minf = inf;
for i=0:(2^(col)-1) %枚举空间
x1 = myDec2Bin(i,col); %十进制转化为二进制if A*x1 >= b %是否满足约束条件
f_tmp = c*x1;
if f_tmp < minf
minf = f_tmp;
intx = x1;
intf = minf;
else
continue;
end
else
continue;
end
end
function [intx,intf] = Implicitprog(c,A,b,x0)%隐枚举法
sz_A = size(A);
rw = sz_A(1);
col = sz_A(2);
minf = c*x0;
A = [A;-c];
b = [b;-minf]; %增加了一个限制分量
for i=0:(2^(col)-1)
x1 = myDec2Bin(i,col);
if A*x1 >= b
f_tmp = c*x1;
if f_tmp < minf
minf = f_tmp;
b(rw+1,1) = -minf; %隐枚举法与穷举法的区别在于此句 intx = x1;
intf = minf;
else
continue;
end
else
continue;
end
end
function y = myDec2Bin(x,n) %十进制转化为二进制
str = dec2bin(x,n);
for j=1:n
y(j) = str2num(str(j));
end
y = transpose(y);
四、算法实现
例1.求解下面0-1规划
()⎪⎩⎪⎨⎧=≥++++≥++++++++=105224287453232min 5
4321543215432154321或,x ,x ,x ,x x x x x x x x x x x x ,s.t.x x x x x x f
解:在MATLAB 命令框在输入下列命令:
>> c=[1 2 3 1 1];
>> A=[2 3 5 4 7;1 1 4 2 2];
>> b=[8;5];
>> x0=[1;1;1;1;1];
>> [intx,intf]=ZeroOneprog(c,A,b,x0) 所得结果如下:
123
1231231213
123max 3252244..346,,01
z x x x x x x x x x s t x x x x x x x =-++-≤⎧⎪++≤⎪⎪+≤⎨⎪+≤⎪⎪⎩为或 解:在MATLAB 命令框在输入下列命令: >> c=[-3,2,-5];
>> A=[-1,-2,1;-1,-4,-1;-1,-1,0;-4,0,-1]; >> b=[-2;-4;-3;-6];
>> x0=[1;0;0];
>> [intx,intf]=ZeroOneprog(c,A,b,x0)
1234
12341234124min 3721648..535
01,1,2,3,4j z x x x x x x x x x x x x s t x x x x j =+-+-+-≥⎧⎪-++≥⎪⎨++≥⎪⎪==⎩
或 解:在MATLAB 命令框在输入下列命令: >> c=[3,7,-1,1];
A=[2,-1,1,-1;1,-1,6,4;5,3,0,1]; b=[1;8;5];
>> x0=[1;1;1;1];
>> [intx,intf]=ZeroOneprog(c,A,b,x0)
123
123123123max 62323352..24
01,1,2,3j z x x x x x x x x x s t x x x x j =++++≤⎧⎪-+≥⎪⎨++≤⎪⎪==⎩

解:在MATLAB 命令框在输入下列命令: >> c=[-6,-2,-3];
A=[-1,-2,-1;3,-5,1;-2,-1,-1];
b=[-3;2;-4];
x0=[1;0;0];
[intx,intf]=ZeroOneprog(c,A,b,x0)。

相关文档
最新文档