码迷,mamicode.com
首页 > 其他好文 > 详细

动态规划—装配线调度

时间:2014-07-27 10:26:42      阅读:353      评论:0      收藏:0      [点我收藏+]

标签:

前言:

  分治法是将问题划分成一些独立的子问题,递归地求解各子问题,然后合并子问题的解而得到原问题的解。

  动态规划(Dynamic Programming)是通过组合子问题的解而解决整个问题。它适用于子问题不是独立的情况,也就是各个子问题包含公共的子问题。在这种情况下,若用分治法会做许多不必要的工作,即重复地求解公共的子问题。动态规划对每个子问题只求解一次,将其结果保存在一张表中,从而避免每次遇到各个子问题时重新计算答案。

  动态规划通常用于最优化问题。【此类问题可能有很多种可行解,我们希望找到一个具有最优值的解】。

  动态规划算法设计步骤:

  1、描述最优解的结构。

  2、递归定义最优解的值。

  3、按自底向上的方式计算最优解的值。

  4、由计算出的结果构造一个最优解。

  经典动态规划例题之一:装配线调度问题。

问题描述:

  Colonel汽车公司在有两条装配线上的工厂内生产汽车,如下图所示。每条装配线上有n个装配站,编号为j=1,2,......,n。将装配线i(i为1或2)的第j个装配站表示为Si,j 。装配线1的第j个站和装配站2的第j个站执行相同的功能,但是由于装配站性能不同,所需要的装配时间各不相同。把在装配站Si,j上所需的时间表示为ai,j,汽车底盘进入装配线i的时间为ei,离开装配线i的时间为xi

  正常情况下,汽车在一条装配线上完成装配。当有紧急订单时,允许汽车从任一装配站上移动至另外一条装配线上,以加快装配速度,但是仍然要经过n道工序。从Si,j移动至另外一条装配线的时间表示为ti,j,i=1,2,j=1,2,3,...,n-1(第n个之后,装配已经完成)。

  bubuko.com,布布扣

  目标是确定选择装配线1和2中的哪些站,以使汽车制造时间最短?

实例解题:

  对于下图实例,

  bubuko.com,布布扣

    结果序列:S1,1,S2,2,S1,3,S2,4,S2,5,S1,6

    时间结果:2+(7)+2+(5)+1+(3)+1+(4)+(5)+1+(4)+3 = 38

解题步骤:

  1、描述最优解结构的特征

    动态规划方法的第一个步骤是描述最优解结构的特征。对于装配线问题,可以考虑从起始点到装配站S1,j的最快路线:如果j=1,则只有一条路线,对于j=2,3,..., n,则有两种选择:

      从装配站S1,j-1直接通过S1,j

      从装配站S2,j-1,转移至S1,j后通过,移动代价为t2,j-1

    分别考虑这两种可能,它们之间具有很多共性。

    首先,假设通过装配站S1,j 的最快路线通过了S1,j-1。则它一定是利用最快路线从开始到达S1,j-1的。为什么呢?如果存在一条更快的路线通过S1,j-1,就可以采用这条路线,从而  得到通过S1,j 的更快路线,这与假设矛盾。

    同样,假设通过S1,j的最快路线通过了S2,j-1。则它一定是利用最快路线从开始到达S2,j-1的。理由与上述相同。

    更一般的讲,对于装配线调度问题,一个问题的最优解(找出通过Si,j的最快路线)包含了子问题(找出通过S1,j-1或者S2,j-1的最快路线)的一个最优解。这种性质叫最优子结构,  这是判断是否可以用动态规划方法的标志之一。

    利用子问题的最优解来构造原问题的最优解。对于装配线调度问题,推理如下:观察一条通过S1,j的最快路线,会发现它必定是经过装配线1或2的装配站j-1.因此,通过装配站S1,j的最快路线只能是以下二者之一:

      通过S1,j-1的最快路线,然后直接通过装配站S1,j

      通过S2,j-1的最快路线,从2线移到1线,然后通过S1,j

    同样道理,通过S2,j的最快路线也只能是以下二者之一:

      通过S2,j-1的最快路线,然后直接通过装配站S2,j

      通过S1,j-1的最快路线,从1线移到2线,然后通过S2,j

  那么,为了寻找通过任一条装配线上装配站j的最快路线,要解决它的子问题:确定两条装配线上通过装配站j-1的最快路线。

  2、递归求解

    第二个步骤是利用子问题的最优解来递归定义一个最优解的值。对于装配线调度问题,选择在两条装配线上通过装配站j的最快路线作为子问题,j=1,2,....., n。令fi[j]表示一个从起点  到装配站Si,j的最快时间。最终目标是确定汽车通过工厂的所有路线中的最快路线和时间,最快时间表示为f*。最终必须经过装配站n,到达工厂出口。那么有:

      f* = min{f1[n]+x1,f2[n]+x2}

    而,推理f1[1]和f2[1]也比较容易:

      f1[1]=e1+a1,1

      f2[1]=e2+a2,1

    现在考虑如何计算fi[j],其中j=2,3,......,n(i=1,2)。对于f1[j],通过S1,j的最快路线或者是通过S1,j-1后直接通过S1,j,或者是通过装配站S2,j-1,从线2移动至线1后,通过S1,j

    第一种情况下,f1[j]=f1[j-1]+a1,j,第二种情况下,f1[j]=f2[j-1]+t2,j-1+a1,j,因此:

      f1[j]=min{f1[j-1]+a1,j,f2[j-1]+t2,j-1+a1,j}  其中j=2,3,... n。对称的有:

      f2[j]=min{f2[j-1]+a2,j,f1[j-1]+t1,j-1+a2,j}  其中j=2,3, ... n。

    对于实例中的fi[j]和f*,如下表所示:

j 1 2 3 4 5 6
f1[j] 9 18 20 24 32 35
f2[j] 12 16 22 25 30 37
f* 38          

    表中的fi[j]就是子问题的最优解的值。为了有助于跟踪最优解的过程,定义li[j]为装配线的编号(或为1或为2),其上的装配站j-1被通过装配站Si,j的最快路线所用,这里  i=1,2且    j=2,3, ... n,(li[1]没有意义,因为装配站1前面没有装配站)。此外,定义l*表示装配线编号,其上的装配站n被最快路线使用。实例中的li[j]和l*如下表所示:

j 2 3 4 5 6
l1[j] 1 2 1 1 2
l2[j] 1 2 1 2 2
l* 1        

    通过上表可以找到一个最快路线,从l*=1开始,使用装配站S1,6,l1[6]=2则使用装配站S2,5,l2[5]=2则使用S2,4,l2[4]=1则使用S1,3,l1[3]=2则使用S2,2,l2=1则使用S1,1

  3、计算时间

    写一个递归算法来计算最快路线的时间不难,但是,这种递归算法的执行时间是关于n的指数形式。如果在递归的方式中以不同的顺序来计算fi[j]的值,就能节省时间。对于j>1,fi[j]的值仅仅依赖于f1[j-1]和f2[j-1]的值。通过以递增装配站编号j的顺序来计算fi[j]的值,就可以在O(n)时间内的得到最快路线及花费的时间。下面给出FASTEST-WAY算法进行计算程序,其输入为:ai,j ,ti,j ,ei 和xi 以及n。

 1 //装配线调度问题动态规划算法实现
 2 public void Fastest_Way(int [][]a,int [][] t,int [] e,int [] x,int n)
 3 {
 4         
 5     f[0][0] = e[0]+a[0][0];
 6     f[1][0] = e[1]+a[1][0];
 7     for(int j=1;j<=n-1;j++)
 8     {
 9             
10         if(f[0][j-1]+a[0][j]<=f[1][j-1]+t[1][j-1]+a[0][j])
11         {
12             f[0][j] = f[0][j-1]+a[0][j];
13             l[0][j] = 1;
14         }
15         else
16         {
17             f[0][j] = f[1][j-1]+t[1][j-1]+a[0][j];
18             l[0][j] = 2;    
19         }
20         if(f[1][j-1]+a[1][j]<=f[0][j-1]+t[0][j-1]+a[1][j])
21         {
22                 f[1][j] = f[1][j-1]+a[1][j];
23             l[1][j] = 2;    
24         }
25         else
26         {
27             f[1][j] = f[0][j-1]+t[0][j-1]+a[1][j];
28             l[1][j] = 1;        
29         }
30     }
31     if(f[0][n-1]+x[0]<=f[1][n-1]+x[1])
32     {
33         fend = f[0][n-1]+x[0];
34         lend = 1;
35     }
36     else
37         {
38         fend = f[1][n-1]+x[1];
39             lend = 2;
40     }
41 }                    

  4、构造路线

    计算出时间后,需要构造最快路线经过的装配站,第二部分已经说明了做法。下面程序以站号递减的顺序输出最快路线的结果序列。

 1 //打印结果序列(站点号递减顺序)
 3     public void PrintFastWay()
 4     {
 5         int i = lend;
 6         System.out.println("line "+i+",Station"+n);
 7         for(int j=n;j>=2;j--)
 8         {
 9             i = l[i-1][j-1];
10             System.out.println("line "+i+",Station"+ (j-1));
11         }    
12     }

 程序实现:

  1 package dynamic;
  2 
  3 public class FastWay {
  4     
  5     private int [][] a ;
  6     private int [][] t ;
  7     private int [] e;
  8     private int [] x;
  9     private int n;
 10     
 11     private int fend;
 12     private int lend;
 13     private int [][] f;
 14     private int [][] l;
 15     
 16     public void setA(int [][] a) {
 17         this.a = a;
 18     }
 19     public int [][] getA() {
 20         return a;
 21     }
 22     
 23     public int[][] getT() {
 24         return t;
 25     }
 26 
 27     public void setT(int[][] t) {
 28         this.t = t;
 29     }
 30 
 31     public int[] getE() {
 32         return e;
 33     }
 34 
 35     public void setE(int[] e) {
 36         this.e = e;
 37     }
 38 
 39     public int[] getX() {
 40         return x;
 41     }
 42 
 43     public void setX(int[] x) {
 44         this.x = x;
 45     }
 46 
 47     public int getN() {
 48         return n;
 49     }
 50 
 51     public void setN(int n) {
 52         this.n = n;
 53     }
 54     
 55     
 56 
 57 
 58     public int getFend() {
 59         return fend;
 60     }
 61     public void setFend(int fend) {
 62         this.fend = fend;
 63     }
 64     
 65     public int getLend() {
 66         return lend;
 67     }
 68     public void setLend(int lend) {
 69         this.lend = lend;
 70     }
 71     public int[][] getF() {
 72         return f;
 73     }
 74     public void setF(int[][] f) {
 75         this.f = f;
 76     }
 77     public int[][] getL() {
 78         return l;
 79     }
 80     public void setL(int[][] l) {
 81         this.l = l;
 82     }
 83     
 84     //装配线调度问题动态规划算法实现
 85     public void Fastest_Way(int [][]a,int [][] t,int [] e,int [] x,int n)
 86     {
 87         
 88         f[0][0] = e[0]+a[0][0];
 89         f[1][0] = e[1]+a[1][0];
 90         for(int j=1;j<=n-1;j++)
 91         {
 92             
 93             if(f[0][j-1]+a[0][j]<=f[1][j-1]+t[1][j-1]+a[0][j])
 94             {
 95                 f[0][j] = f[0][j-1]+a[0][j];
 96                 l[0][j] = 1;
 97             }
 98             else
 99             {
100                 f[0][j] = f[1][j-1]+t[1][j-1]+a[0][j];
101                 l[0][j] = 2;    
102             }
103             if(f[1][j-1]+a[1][j]<=f[0][j-1]+t[0][j-1]+a[1][j])
104             {
105                 f[1][j] = f[1][j-1]+a[1][j];
106                 l[1][j] = 2;    
107             }
108             else
109             {
110                 f[1][j] = f[0][j-1]+t[0][j-1]+a[1][j];
111                 l[1][j] = 1;        
112             }
113         }
114         if(f[0][n-1]+x[0]<=f[1][n-1]+x[1])
115         {
116             fend = f[0][n-1]+x[0];
117             lend = 1;
118         }
119         else
120         {
121             fend = f[1][n-1]+x[1];
122             lend = 2;
123         }
124     }
125     //打印结果序列(站点号递减顺序)
126     public void PrintFastWay()
127     {
128         int i = lend;
129         System.out.println("line "+i+",Station"+n);
130         for(int j=n;j>=2;j--)
131         {
132             i = l[i-1][j-1];
133             System.out.println("line "+i+",Station"+ (j-1));
134         }    
135     }    
136 }

 1 package dynamic;
 2 
 3 public class DynamicMain {
 4 
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10 
11         int [][] a = {{7,9,3,4,8,4},{8,5,6,4,5,7}};
12         int [][] t = {{2,3,1,3,4},{2,1,2,2,1}};
13         int [] e = {2,4};
14         int [] x = {3,2};
15         int n = a[1].length;
16         
17         int [][] f = {{0,0,0,0,0,0},{0,0,0,0,0,0}};
18         int [][] l = {{0,0,0,0,0,0},{0,0,0,0,0,0}};
19         
20         FastWay fastWay = new FastWay();
21         fastWay.setA(a);
22         fastWay.setE(e);
23         fastWay.setT(t);
24         fastWay.setX(x);
25         fastWay.setN(n);
26         
27         fastWay.setF(f);
28         fastWay.setL(l);
29         fastWay.setFend(0);
30         fastWay.setLend(1);
31         
32         fastWay.Fastest_Way(a, t, e, x, n);
33         System.out.println("最快路线花费的时间:");
34         System.out.println(fastWay.getFend());
35         System.out.println("最快的路线:");
36         fastWay.PrintFastWay();
37     }
38 
39 }

 

程序结果:

  最快路线花费的时间:
   38
  最快的路线:
   line 1,Station6
   line 2,Station5
   line 2,Station4
   line 1,Station3
   line 2,Station2
   line 1,Station1

动态规划—装配线调度

标签:

原文地址:http://www.cnblogs.com/Jiaoxia/p/3868232.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!