装配线调度（动态规划）
1. 问题描述
公司在有两条装配线的工厂内生产汽车，如下图所示。一个汽车底盘在进入每一条装配线后，在一些装配站中会在底盘上安装部件，然后完成的汽车在装配站的末端离开。每一条装配线上有n个装配站，编号为j=1，2...n。装配线i（i=1，2）的第j个装配站表示为Sij。装配线1的第j个站和装配线2的第j个站执行相同的功能。然而这些装配站是在不同的时间建造的，并且采用了不同的技术，一次每个站上所需的时间是不同的，即使在两条不同装配线相同位置的装配站上也是这样。
各时间参数如下：
ei：汽车进入装配线i的时间，i=1,2；
xi：汽车离开装配线i的时间，i=1,2；
aij：在装配站Sij完成装配需要的时间；
tij：在装配站Sij完成后离开第i条装配线，进入另一条装配线需要的转移时间；
如果完成工序后，下一个工序还在同一条装配线上，则不需要转移时间。
请找出从汽车进入装配线开始到结束的最短时间和经过的装配站路线。
2. 分析
（1） 优化子结构
考虑底盘从起始点到S1j的最快可能路线和从起始点到S2j的最快可能路线。
通过装配站S1j的最快路线只能是一下二者之一：
1） 通过装配站S1,j-1的最快路线，然后直接通过装配站S1,j。 （此时L[1][j] = 1）
2） 通过装配站S2,j-1的最快路线，然后从装配线2移动到装配站S1j。（此时L[1][j] = 2）
类似的，
通过装配站S2j的最快路线只能是一下二者之一：
1） 通过装配站S2,j-1的最快路线，然后直接通过装配站S2,j。 （此时L[2][j] = 2）
2） 通过装配站S1,j-1的最快路线，然后从装配线1移动到装配站S2j。（此时L[2][j] = 1）
（2） 递推公式
令f[i][j]表示一个底盘从起点到装配站Sij的最快可能时间（i=1,2；j=1,2...n），则最终的最快时间为：
f = min{f[1][n]+x1，f[2][n]+x2}
经过以上分析递推公式如下：
为了跟踪最优解的构造过程，定义L[i][j]为通过装配站Sij的最快路线中，Sij前一站所在的装配线的编号i，即1或2。此时i=1,2；j=2，3...n
3. 根据递推公式写出算法
代码如下：
/**
* n: the number of assembly station
* e[i]: the time of entering assembly line i, i = 0, 1
* x[i]: the time of leaving assemblu line i, i = 0, 1
* a[i][j]: the time of assembly station Sij, i = 0, 1; j = 0, 1...n-1
* t[i][j]: the transfering time of leaving assembly station Sij to another assembly line
* l[i][j]: the assembly line number from which assembly line to Sij, i = 0, 1; j = 1, 2...n
* */
void assemblyLineScheduling(int n, int e[], int x[], int t[][n], int a[][n])
{
int f[2][n], ft, j, l[2][n], t0, t1;
f[0][0] = e[0] + a[0][0];
f[1][0] = e[1] + a[1][0];
for (j = 1; j < n;j++)
{
//f[0][j]
t0 = f[0][j - 1] + a[0][j]; // from assembly line 0
t1 = f[1][j - 1] + t[1][j - 1] + a[0][j]; // from assembly line 1
f[0][j] = t0 <= t1 ? (l[0][j] = 0, t0) : (l[0][j] = 1, t1);
//f[1][j]
t0 = f[0][j - 1] + t[0][j - 1] + a[1][j]; // from assembly line 0
t1 = f[1][j - 1] + a[1][j]; // from assembly line 1
f[1][j] = t0 >= t1 ? (l[1][j] = 1, t1) : (l[1][j] = 0, t0);
}
t0 = f[0][n - 1] + x[0];
t1 = f[1][n - 1] + x[1];
ft = t0 > t1 ? (j = 1, t1) : (j = 0, t0);
printf("the shortest time is %d\n", ft);
print_station(n, l, j); //逆序打印选择的装配站
//print_station2(n, n, l, j);//正序打印选择的装配站
}逆序打印装配站的代码如下：
/**
* n: the number of assembly stations
* */
void print_station(int n, int l[][n], int i)
{
int j;
printf("line %d, station %d\n", i, n - 1);
for (j = n - 1; j > 0; j--)
{
i = l[i][j];
printf("line %d, station %d\n", i, j - 1);
}
printf("\n");
}
正序递归打印装配站的代码：
void print_station2(int num, int n, int l[][n], int i)
{
if (num >= 1) {
print_station2(num - 1, n, l, l[i][num - 1]);
printf("line %d, station %d\n", i, num - 1);
}
} 测试代码：
#include
void assemblyLineScheduling(int n, int e[], int x[], int t[][n], int a[][n]);
void print_station(int n, int l[][n], int i);
void print_station2(int num, int n, int l[][n], int i);
int main(void)
{
int n = 6;
int e[] = {2, 4}, x[] = {3, 2};
int a[2][6] = {7, 9, 3, 4, 8, 4, 8, 5, 6, 4, 5, 7};
int t[2][6] = {2, 3, 1, 3, 4, -1, 2, 1, 2, 2, 1, -1};
assemblyLineScheduling(n, e, x, t, a);
return 0;
}
输出：