动态规划（DP）-装配线调度问题

前言：动态规划的概念

　　动态规划（dynamic programming）是通过组合子问题的解而解决整个问题的。分治算法是指将问题划分为一些独立的子问题，递归的求解各个问题，然后合并子问题的解而得到原问题的解。例如归并排序，快速排序都是采用分治算法思想。而动态规划与此不同，适用于子问题不是独立的情况，也就是说各个子问题包含有公共的子问题。如在这种情况下，用分治算法则会重复做不必要的工作。采用动态规划算法对每个子问题只求解一次，将其结果存放到一张表中，以供后面的子问题参考，从而避免每次遇到各个子问题时重新计算答案。

动态规划与分治法之间的区别：

（1）分治法是指将问题分成一些独立的子问题，递归的求解各子问题
（2）动态规划适用于这些子问题不是独立的情况，也就是各子问题包含公共子问题

　　动态规划通常用于最优化问题（此类问题一般有很多可行解，我们希望从这些解中找出一个具有最优（最大或最小）值的解）。动态规划算法的设计分为以下四个步骤：

（1）描述最优解的结构
（2）递归定义最优解的值
（3）按自低向上的方式计算最优解的值
（4）由计算出的结果构造一个最优解

　　动态规划最重要的就是要找出最优解的子结构。书中接下来列举4个问题，讲解如何利用动态规划方法来解决。动态规划的内容比较多，我计划每个问题都认真分析，写成日志。今天先来看第一个问题：装配线调度问题
　　

问题描述

　　
　　一个汽车公司在有2条装配线的工厂内生产汽车，每条装配线有n个装配站，不同装配线上对应的装配站执行的功能相同，但是每个站执行的时间是不同的。在装配汽车时，为了提高速度，可以在这两天装配线上的装配站中做出选择，即可以将部分完成的汽车在任何装配站上从一条装配线移到另一条装配线上。装配过程如下图所示：
　　
　　装配过程的时间包括：进入装配线时间e、每装配线上各个装配站执行时间a、从一条装配线移到另外一条装配线的时间t、离开最后一个装配站时间x。举个例子来说明，现在有2条装配线，每条装配线上有6个装配站，各个时间如下图所示：

从图中可以看出按照红色箭头方向进行装配汽车最快，时间为38。分别现在装配线1上的装配站1、3和6，装配线2上装配站2、4和5。
3、动态规划解决步骤
（1）描述通过工厂最快线路的结构
　　对于装配线调度问题，一个问题的（找出通过装配站Si,j的 最快线路）最优解包含了子问题（找出通过S1,j-1或S2,j-1的最快线路）的一个最优解，这就是最优子结构。观察一条通过装配站S1,j的最快线路，会发现它必定是经过装配线1或2上装配站j-1。因此通过装配站的最快线路只能以下二者之一：
a)通过装配线S1,j-1的最快线路，然后直接通过装配站Si,j；
b)通过装配站S2,j-1的最快线路，从装配线2移动到装配线1，然后通过装配线S1,j。
为了解决这个问题，即寻找通过一条装配线上的装配站j的最快线路，需要解决其子问题，即寻找通过两条装配线上的装配站j-1的最快线路。
（2）一个递归的解
　　最终目标是确定底盘通过工厂的所有路线的最快时间，设为f*，令fi[j]表示一个底盘从起点到装配站Si,j的最快时间，则f* = min(f1[n]+x1,f2[n]+x2)。逐步向下推导，直到j=1。

当j=1时: f1[1] = e1+a1,1,f2[1] = e2+a2,1。
当j>1时：f1[j] = min(f1[j-1]+a1,j，f2[j-1]+t2,j-1+a1,j)，f2[j] = min(f2[j-1]+a2,j，f1[j-1]+t1,j-1+a2,j)。

（3）计算最快时间
　　有了递归的解，就可以按照上述的思路编写程序实现，为了避免用递归实现，需要开辟辅助空间来进行，以空间来换取时间，原文采用C语言实现，本文采用Java：
　　

public void FindFastestWay() {
        Console(lineList);
        Console(shiftList);

        // init start
        lineCurrentStationTime[0][0] = eValue[0]+lineList[0][0];
        lineCurrentStationTime[1][0] = eValue[1]+lineList[1][0];
        CurrentStation[0][0] = 1;
        CurrentStation[1][0] = 2;

        for (int i = 1; i < STATION_COUNT; i++) {
            // line1 f1(n)
            if (lineCurrentStationTime[0][i-1] < lineCurrentStationTime[1][i-1]+shiftList[1][i-1]) {
                lineCurrentStationTime[0][i] = lineCurrentStationTime[0][i-1] + lineList[0][i]; // f1.1 min no shift
                CurrentStation[0][i] = 1; // from line1
            } else {
                // with shift
                lineCurrentStationTime[0][i] = lineCurrentStationTime[1][i-1] + shiftList[1][i-1] + lineList[0][i]; // f1.1 min with shift
                CurrentStation[0][i] = 2; // from line2 
            }

            // line2 f2(n)
            if (lineCurrentStationTime[1][i-1] < lineCurrentStationTime[0][i-1]+shiftList[0][i-1]) {
                lineCurrentStationTime[1][i] = lineCurrentStationTime[1][i-1]+lineList[1][i];
                CurrentStation[1][i] = 2; // from line2
            } else {
                lineCurrentStationTime[1][i] = lineCurrentStationTime[0][i-1] + shiftList[0][i-1] + lineList[1][i];
                CurrentStation[1][i] = 1; // from line1
            }

        }

        if (lineCurrentStationTime[0][STATION_COUNT-1]+xValue[0] < lineCurrentStationTime[1][STATION_COUNT-1]+xValue[1] ) {
            // out from line1
            timeUsed = lineCurrentStationTime[0][STATION_COUNT-1] + xValue[0];
            lastStation = 1;
        } else {
            // out from line2
            timeUsed = lineCurrentStationTime[1][STATION_COUNT-1] + xValue[1];
            lastStation = 2;
        }

        Console(lineCurrentStationTime);
        Console(CurrentStation);
        System.out.println("End line: "+lastStation);
        System.out.println("Timeused: "+timeUsed);
    }

（4）构造通过工厂的最快线路


public void Path() {
System.out.println("Line: "+lastStation+"StationID: "+STATION_COUNT);
int j = lastStation;
for (int i = STATION_COUNT-1; i > 0; i--) {
j = CurrentStation[j-1][i];


4、编程实现

public class AssembleLine {

public static final int STATION_COUNT = 6;

public int [][] lineList = {{7,9,3,4,8,4}, {8,5,6,4,5,7}}; // 存储每个工作站所需要的时间
public int [][] shiftList = {{2,3,1,3,4}, {2,1,2,2,1}}; // 存储工作站在工作线之间转换的时间

public int [][] lineCurrentStationTime = {{0,0,0,0,0,0}, {0,0,0,0,0,0}}; // line1的工作站执行时间
public int [][] CurrentStation = {{0,0,0,0,0,0}, {0,0,0,0,0,0}}; // line2的工作站执行时间

public int [] eValue = {2, 4}; // 存储开始进入装配线的耗时
public int [] xValue = {3, 2}; // 存储退出装配线的耗时

public int timeUsed;
public int lastStation;


public void Console(int [][] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j]+" | ");
        }
        System.out.println();
    }
}

public void FindFastestWay() {
    Console(lineList);
    Console(shiftList);

    // init start
    lineCurrentStationTime[0][0] = eValue[0]+lineList[0][0];
    lineCurrentStationTime[1][0] = eValue[1]+lineList[1][0];
    CurrentStation[0][0] = 1;
    CurrentStation[1][0] = 2;

    for (int i = 1; i < STATION_COUNT; i++) {
        // line1 f1(n)
        if (lineCurrentStationTime[0][i-1] < lineCurrentStationTime[1][i-1]+shiftList[1][i-1]) {
            lineCurrentStationTime[0][i] = lineCurrentStationTime[0][i-1] + lineList[0][i]; // f1.1 min no shift
            CurrentStation[0][i] = 1; // from line1
        } else {
            // with shift
            lineCurrentStationTime[0][i] = lineCurrentStationTime[1][i-1] + shiftList[1][i-1] + lineList[0][i]; // f1.1 min with shift
            CurrentStation[0][i] = 2; // from line2 
        }

        // line2 f2(n)
        if (lineCurrentStationTime[1][i-1] < lineCurrentStationTime[0][i-1]+shiftList[0][i-1]) {
            lineCurrentStationTime[1][i] = lineCurrentStationTime[1][i-1]+lineList[1][i];
            CurrentStation[1][i] = 2; // from line2
        } else {
            lineCurrentStationTime[1][i] = lineCurrentStationTime[0][i-1] + shiftList[0][i-1] + lineList[1][i];
            CurrentStation[1][i] = 1; // from line1
        }

    }

    if (lineCurrentStationTime[0][STATION_COUNT-1]+xValue[0] < lineCurrentStationTime[1][STATION_COUNT-1]+xValue[1] ) {
        // out from line1
        timeUsed = lineCurrentStationTime[0][STATION_COUNT-1] + xValue[0];
        lastStation = 1;
    } else {
        // out from line2
        timeUsed = lineCurrentStationTime[1][STATION_COUNT-1] + xValue[1];
        lastStation = 2;
    }

    Console(lineCurrentStationTime);
    Console(CurrentStation);
    System.out.println("End line: "+lastStation);
    System.out.println("Timeused: "+timeUsed);
}

public void Path() {
    System.out.println("Line: "+lastStation+"StationID: "+STATION_COUNT);

    int j = lastStation;
    for (int i = STATION_COUNT-1; i > 0; i--) {
        j = CurrentStation[j-1][i];
        System.out.println("Line: "+j+"StationID: "+i);
    }
}

public void PathRecursive() {

}

public static void main(String[] args) {
    AssembleLine al = new AssembleLine();
    al.FindFastestWay();
    al.Path();
}

}

程序执行结果如下所示：

5、总结
　　动态规划是个非常有效的设计方法，要善于用动态规划去分析问题，重点是如何发现子问题的结构。最优子结构在问题域中以两种方式变化（在找出这两个问题的解之后，构造出原问题的最优子结构往往就不是难事了）：
a) 有多少个子问题被用在原问题的一个最优解中
b) 在决定一个最优解中使用哪些子问题有多少个选择

文章转载自：http://www.cnblogs.com/Anker/archive/2013/03/09/2951785.html