ACM: 《黑书》高性能计算机

高性能计算机

问题描述:

       1.题目长, 我省略前面的了, 现在又一部超级计算机, 有三个工作状态A类, B类和待机, 它具有P个计算节点, 待机状态不执行计算, 并且初始状态为待机状态. 从其它状态(待机)转入A工作状态或B工作状态需要一定的启动时间. 对于不同的处理节点, 这个时间不一定相同. 用两个正整数ta[i]和tb[i](i = 1,2,3...,p)分别表示节点i转入工作状态A和工作状态B的启动时间(单位：ns).

       2.一个节点连续处理同一类任务时候, 执行时间——不含状态转换的时间——随任务量(这一类子任务的数目)的平方增长, 即: t = ka[i]*x^2,类似执行B任务x个的时间是: t = kb[i]*x^2,对应的执行时间为:其中, ka[i]和kb[i]是系数, 单位是ns.

       任务分配必须在所有计算开始之前完成,所谓任务分配, 即给每个计算节点设置一个任务队列, 队列由一串A类和B类子任务组成. 两类子任务可以交错排列.

       计算开始后, 各计算节点分别从各自的子任务队列中顺序读取计算任务并执行, 队列中连续的同类子任务将由该计算节点一次性读出, 队列中一串连续的同类子任务不能被分成两部分执行.

      现在需要你编写程序, 给这p个节点安排计算任务, 使得这个工程计算任务能够尽早完成. 假定任务安排好后不再变动,而且所有的节点都同时开始运行,任务安排的目标是使最后结束计算的节点的完成时间尽可能早.

 

输入:

     第一行是p, 第二行na, nb, 分别表示A类和B类任务个数. 接着的p行是ta[i],tb[i], ka[i], kb[i]

     表示每个计算节点的参数. (i = 1,2,3,...,p); (0<p<=20, 0<= na,nb<=60)

输出:

     输出一行, 全部任务完成的最短时间.

 

输入例子:

5 5

3

15 10 6 4

70 100 7 2

30 70 1 6

输出例子:

93

 

题意: 见原文.

 

解题思路: (黑书解题思路, 加上自己的思考)

      1. 问题有2个子问题:

      (1). 计算第i个节点完成ai个A任务和bi个B任务需要的最短时间.

      (2). 给第i个节点分配ai个A任务和bi个B任务, 去所有节点运行时间最大值作为实际运行时间.

      2.(1)对于子问题(1),  t[i][A/B][ai][bi]表示:第i个节点, 还有ai个A任务和bi个B任务,当前执行

         完的任务是A或则B任务的最短时间, 可以列出方程:

         t[i][A][ai][bi] = min(t[i][B][j-t1][k]+ta[i]+ka[i]*t1*t1) (1<=t1<=ai)

         t[i][B][ai][bi] = min(t[i][A][j][k-t2]+tb[i]+kb[i]*t2*t2) (1<=t2<=bi)

         初始化问题:  

          t[i][A][j][0] = ta[i]+ka[i]*j*j;

          t[i][B][0][j] = tb[i]+kb[i]*j*j;

         (2)可以再设time[i][ai][bi]表示: 第i个节点完成ai个A任务和bi个B任务需要的最短时间.

         time[i][j][k] = min(t[i][A][j][k], t[i][B][j][k]);

         初始化问题:

         time[i][j][0] = t[i][A][j][0];

         time[i][0][j] = t[i][B][0][j];

       3.对于子问题(2), 这里使我们要求解问题的最后一步, 设状态dp[i][ai][bi]表示: 前i个节点

         执行完ai个A任务和bi个B任务的最短时间. 可列出方程:

         dp[i][ai][bi] = min( max(dp[i-1][ai-t1][bi-t2], time[i][t1][t2]) );

         (0<=t1<=ai, 0<=t2<=bi, 0<= ai <= na , 0 <= bi <= nb)

         初始化: dp[1][ai][bi] = time[1][ai][bi];

       4. 综上所述: 显然时间复杂度O(p*a^2*b^2); 递推求解问题还是可以接受的.

 

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
#define MAX 61
#define MAXN 21
#define A 0
#define B 1
const int INF = (1<<30);

int n, na, nb;
int ta[MAXN], tb[MAXN], ka[MAXN], kb[MAXN];
int t[MAXN][2][MAX][MAX], time[MAXN][MAX][MAX];
int dp[MAXN][MAX][MAX];
int tempA, tempB, temp;

inline int max(int a, int b)
{
 return a > b ? a : b;
}

inline int min(int a, int b)
{
 return a < b ? a : b;
}

void DP1()
{
 int i, j, k, t1, t2;
 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= na; ++j)
   t[i][A][j][0] = ta[i]+ka[i]*j*j;
 }

 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= nb; ++j)
   t[i][B][0][j] = tb[i]+kb[i]*j*j;
 }

 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= na; ++j)
  {
   for(k = 1; k <= nb; ++k)
   {
    tempA = tempB = INF;
    for(t1 = 1; t1 <= j; ++t1)
    {
     for(t2 = 1; t2 <= k; ++t2)
     {
      tempA = min(tempA, t[i][B][j-t1][k]+ta[i]+ka[i]*t1*t1);
      tempB = min(tempB, t[i][A][j][k-t2]+tb[i]+kb[i]*t2*t2);
     }
    }
    t[i][A][j][k] = tempA;
    t[i][B][j][k] = tempB;
   }
  }
 }

 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= na; ++j)
   time[i][j][0] = t[i][A][j][0];
 }

 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= nb; ++j)
   time[i][0][j] = t[i][B][0][j];
 }

 for(i = 1; i <= n; ++i)
 {
  for(j = 1; j <= na; ++j)
  {
   for(k = 1; k <= nb; ++k)
    time[i][j][k] = min(t[i][A][j][k], t[i][B][j][k]);
  }
 }
}

void DP2()
{
 int i, j, k, t1, t2;
 for(i = 0; i <= na; ++i)
 {
  for(j = 0; j <= nb; ++j)
   dp[1][i][j] = time[1][i][j];
 }

 for(i = 2; i <= n; ++i)
 {
  for(j = 0; j <= na; ++j)
  {
   for(k = 0; k <= nb; ++k)
   {
    temp = INF;
    for(t1 = 0; t1 <= j; ++t1)
    {
     for(t2 = 0; t2 <= k; ++t2)
      temp = min(temp, max(dp[i-1][j-t1][k-t2], time[i][t1][t2]));
    }
    dp[i][j][k] = temp;
   }
  }
 }
}

int main()
{
 int i;
// freopen("input.txt", "r", stdin);
 while(scanf("%d",&n) != EOF)
 {
  scanf("%d %d",&na, &nb);
  for(i = 1; i <= n; ++i)
   scanf("%d %d %d %d",&ta[i], &tb[i], &ka[i], &kb[i]);

  memset(t, 0, sizeof(t));
  memset(time, 0, sizeof(time));
  memset(dp, 0, sizeof(dp));
  DP1();
  DP2();

  printf("%d\n",dp[n][na][nb]);
 }
 return 0;
}