转自:http://hi.baidu.com/liongg/blog/item/63d6a9ec19454c2262d09f01.html(有修改)
研究一个实例:
n=6
a = {2, 5, 7, 10, 5, 2};
b = {3, 8, 4, 11, 3, 4}.
分析:当完成k个作业,设机器A花费了x时间,机器B所花费时间的最小值肯定是x的一个函数,设F[k][x]表示机器B所花费时间的最小值(注意,这是B机器所花费的时间,即当B机器停机时的时间点)。则有
F[k][x]=Min{ F[k-1][x]+b[k], F[k-1][x-a[k]] };
其中,F[k-1][x]+b[k]表示第k个作业由机器B来处理(完成k-1个作业时机器A花费的时间仍是x,前提就是A机器停机的时间是x),F[k-1][x-a[k]]表示第k个作业由机器A处理(完成k-1个作业时机器A花费的时间是x-a[k])。
初始化第一个作业:下标以0开始。
首先,机器A所花费时间的所有可能值范围:0 <= x <= a[0].
设x<0时,设F[0][x]= ∞,则max(x, ∞)= ∞;记法意义见下。
x=0时,F[0][0]=3,则Max(0,3)=3,机器A花费0时间,机器B花费3时间,而此时两个机器所需时间为3;
x=1时,F[0][1]=3,Max(1,3)=3;
x=2时,F[0][2]=0,则Max(2,0)=2;
那么上面的点对序列中,可以看出当x=2时,完成第一个作业两台机器花费最少的时间为2,此时机器A花费2时间,机器B花费0时间。
来看第二个作业:
首先,x的取值范围是:0 <= x <= (a[0] + a[1]).
当x<0时,记F[1][x] = ∞;这个记法编程使用,因为数组下标不能小于0。在这里的实际含义是:x是代表完成前两个作业机器A的时间,a[1]是机器A完成第2个作业的时间,若x<a[1],则势必第2个作业由机器B来处理,即在Min()中取前者。
x=0,则F[1][0]= Min{ F[0][0]+b[2], F[0][0-a[1]] }= Min{3+8,∞}=11,进而Max(0,11)=11;
x=1,则F[1][1]= Min{ F[0][1]+b[2], F[0][1-a[1]] }= Min{3+8,∞}=11,进而Max(11)=11;
x=2,则F[1][2]= Min{ F[0][2]+b[2], F[0][2-a[1]] }= Min{0+8,∞}=8,进而Max(2,8)=8;
x=3,则F[1][3]= Min{ F[0][3]+b[2], F[0][3-a[1]] }= Min{0+8,∞}=8,进而Max(3,8)=8;
x=4,则F[1][4]= Min{ F[0][4]+b[2], F[0][4-a[1]] }= Min{0+8,∞}=8,进而Max(4,8)=8;
x=5,则F[1][5]= Min{ F[0][5]+b[2], F[0][5-a[1]] }= Min{0+8,3}=3,进而Max(5,3)=5;
x=6,则F[1][6]= Min{ F[0][6]+b[2], F[0][6-a[1]] }= Min{0+8,3}=3,进而Max(6,3)=6;
x=7,则F[1][7]= Min{ F[0][7]+b[2], F[0][7-a[1]] }= Min{0+8,0}=0,进而Max(7,0)=7;
那么上面的点对序列中,可以看出当x=5时,完成两个作业两台机器花费最少的时间为5,此时机器A花费5时间,机器B花费3时间。
- <span style="font-size:16px;">using System;
- namespace zydd
- {
- class Program
- {
- //独立任务最优调度函数,参数为两组任务和任务个数,最优时间和顺序结果。
- static void DlrwZydd(int[] a, int[] b, int n, int[] least, string[] result)
- {
- //首先给一个大值。
- for (int i = 0; i < n; i++)
- {
- least[i] = 99;
- }
- //若任务只有一台机器完成,求得两个时间。
- int aSum = 0, bSum = 0;
- for (int i = 0; i < n; i++)
- {
- aSum += a[i];
- bSum += b[i];
- }
- //小值加1作为数组的列数,减少存储空间。
- int Sum = 1 + Math.Min(aSum, bSum);
- //创建四个行数列数相同的数组,timeA存储机器A可能用的时间,timeB存储对应机器B用的时间,
- //timeMax记录两者共需的时间,即较大的那个;who则标识完成该任务的机器是A还是B。
- int[,] timeA = new int[n, Sum];
- int[,] timeB = new int[n, Sum];
- int[,] timeMax = new int[n, Sum];
- char[,] who = new char[n, Sum];
- char[] tempRlt = new char[n];//tempRlt记录机器完成任务的机器顺序,并逐一赋值给result
- //先计算第1个任务相关值,记录在四个数组的第0行。
- for (int i = 0; i <= a[0]; i++)
- {
- timeA[0, i] = i;
- if (i < a[0])
- {
- timeB[0, i] = b[0];
- who[0, i] = 'b';
- }
- else
- {
- timeB[0, i] = 0;
- who[0, i] = 'a';
- }
- timeMax[0, i] = Math.Max(timeA[0, i], timeB[0, i]);
- }
- //尽管像下面一样,直接比较即可得出完成第1项任务的最优时间,但由于使用动态规划,计算上述值是必需的。
- if (a[0] <= b[0])
- {
- least[0] = a[0];
- tempRlt[0] = 'a';
- }
- else
- {
- least[0] = b[0];
- tempRlt[0] = 'b';
- }
- result[0] = new String(tempRlt);
- //计算第2个至第n个任务,分别记录在四个数组相应行。
- for (int k = 1; k < n; k++)
- {
- //tempSum记录完成前k项任务机器A最多需要的时间,即全部由A完成需要的时间,亦即机器A所有可能的取值范围。
- int tempSum = 0;
- for (int temp = 0; temp <= k; temp++)
- {
- tempSum += a[temp];
- }
- //计算出所有可能的点对(timeA,timeB),并取值timeMax。
- for (int i = 0; i <= tempSum; i++)
- {
- //机器A在完成前k项任务时所花费的时间为i。
- timeA[k, i] = i;
- //i即timeA[k, i],若机器A完成前k项任务的时间 小于 它完成第k项的时间,可能吗?不可能,所以第k项任务肯定由机器B做。
- if (i < a[k])
- {
- timeB[k, i] = timeB[k - 1, i] + b[k];
- who[k, i] = 'b';
- }
- //按照前述动态规划方式的思想,确定机器A在花费i时间时,机器B花费的最优时间。
- else
- {
- if ((timeB[k - 1, i] + b[k]) <= timeB[k - 1, i - a[k]])
- {
- timeB[k, i] = timeB[k - 1, i] + b[k];
- who[k, i] = 'b';
- }
- else
- {
- timeB[k, i] = timeB[k - 1, i - a[k]];
- who[k, i] = 'a';
- }
- }
- //两台机器花费时间较大的那个为总花费时间。
- timeMax[k, i] = Math.Max(timeA[k, i], timeB[k, i]);
- }
- //处理数组tempSum后面的值。机器A时间全部设为最大,此时机器B则无需花费时间。
- for (int i = tempSum + 1; i < aSum; i++)
- {
- timeA[k, i] = tempSum;
- timeB[k, i] = 0;
- }
- //完成第k项任务后,在timeMax所有可能值中,选取最小值即最优值。
- int flag = 0;//记录最优值所在的位置i值,同时也是机器A所花费的时间。
- for (int i = 0; i <= tempSum; i++)
- {
- if (timeMax[k, i] > 0 && timeMax[k, i] < least[k])
- {
- least[k] = timeMax[k, i];
- flag = i;
- }
- }
- //用来回溯所用机器的顺序,需要注意的是机器A所花费的时间和数组的下标一样,因此可用做标记。
- //最后一项任务的回溯路径已在示意图中标出,便于理解。
- tempRlt[k] = who[k, flag];
- for (int i = k; i > 0 && flag > 0; i--)
- {
- //如果是机器A完成第i项任务,则机器A花费的时间减去a[i]就是完成前i-1项任务的时间。
- //同时在who中可以确定前一项任务的机器,因为机器A花费的时间可用做位置标记。
- if (tempRlt[i] == 'a')
- {
- flag -= a[i];
- tempRlt[i - 1] = who[i - 1, flag];
- }
- if (tempRlt[i] == 'b')
- {
- tempRlt[i - 1] = who[i - 1, flag];
- }
- }
- result[k] = new String(tempRlt);
- }
- }
- static void Main(string[] args)
- {
- const int N = 6;
- int[] a = new int[N] { 2, 5, 7, 10, 5, 2 };
- int[] b = new int[N] { 3, 8, 4, 11, 3, 4 };
- int[] least = new int[N]; //记录完成任务的最优时间
- string[] result = new string[N]; //记录完成任务机器的顺序
- DlrwZydd(a, b, N, least, result);
- Console.WriteLine();
- for (int i = 0; i < N; i++)
- {
- Console.WriteLine(" 按要求完成前{0}项任务的机器顺序为:" + result[i] + " 时间为:{1}" ,i+1,least[i]);
- }
- }
- }
- }
- </span>
便于理解的图: