poj 1857 to europe

/*

 * 要运送车辆到对岸.车辆已经排好队，注意因为桥窄不能超车，

 * 分组的时候不能随意分组，前一组的车辆都排在后一组车辆的前

 * 面，即车辆的顺序是按输入固定的。

 * 只有一座单行的桥

 *

 * 每辆车有其重量及最最快车速

 * 

 * 通过分组方式将车辆分成几组运输，

 * 每次只能运一组运到对岸后第二组才能出发，

 * 

 * 每组中车辆的总重量不能超过桥的载重量，

 * 

 * 运输速度则取决于该组车辆中最慢的那辆

 *

 *问如何分组，运输最快

动态规划，从前向后，依次求出到i位置时的最优解，考i位置的时候，考虑i-1,i-2...

 * 直到i - j加在一起超过了载重量，则所有这些位置可能性都需要考虑到。

 *

 * s(i) = min ( (s(i-1) + (i)time), s(i-2) + (i ,i -1)time .. ,s(i - j) + (i , i - 1, ...i - j + 1)time )

 *

 * w(i) + w(i-1) + ...w(i - j + 1) <= W

 * w(i) +.. w(i - j) > w

 *

 * 可以优化，思路是贪心

 * 考虑如果没有速度区别，应该是考虑i位置的时候向前,该组装的越多越好。

 * 另外即使有速度不同,s(i) <= s(j),when i < j的事实存在。

 * 据此可以优化。 不过优化之后代码稍麻烦，而且提交后发现和没优化用时一样的。 因为复杂度没变还是需要判断那么多，只不过少计算了点，可以再思考如何优化。

  1 #include <stdio.h>

 2 
 3 int b,l,n;    //b the max weight the bridge can afford, l the bridge length, n cars to transport
 4 double r[1001];  // 记录DP算法，到当前位置最优解的最短时间
 5 int w[1001];  // 记录各车的重量
 6 int s[1001];  // 记录各车的速度
 7 
 8 void SolveDP()
 9 {
     l *= 60;    //因为最后求分钟，速度是小时每千米,先*60一样的
     r[0] = 0;
     
     int speed, weight;
     double time_best, time_now;
     
     for (int i = 1; i <= n; i++) {  //从1开始记录下标,r[0] = 0作为哨兵,便于程序统一处理
         
         scanf("%d%d", &(w[i]), &(s[i]));
         
         //第一种分组尝试,i单独一组
         weight = w[i];
         speed = s[i];
         time_best = r[i - 1] + (double)l / (double)speed;
         
         //尝试其它所有可能的包含i的分组
         for (int j = i - 1; j && (weight += w[j]) <= b; j-- ){
             if (s[j] < speed)
                 speed = s[j];
 
             time_now = r[j - 1] + (double)l / (double)speed;
             if (time_now < time_best)
                 time_best = time_now; 
 
         }
         r[i] = time_best;
     }
     printf("%.1f\n", r[n]);
 }
 
 int main(int argc, char *argv[])
 {
     while (1) {
         
         scanf("%d%d%d",&b, &l, &n);
         
         if (b == 0 && l ==0 && n ==0)
             break;
 
         SolveDP();
     }
     return 0;
 }

试图优化 

  1 #include <stdio.h>

 2 const int MaxNum = 1001;  //注意因为从1开始，所以需要1000 + 1
 3 int b,l,n;    //b the max weight the bridge can afford, l the bridge length, n cars to transport
 4 double r[1001];  // 记录DP算法，到当前位置最优解的最短时间
 5 int w[1001];  // 记录各车的重量
 6 int s[1001];  // 记录各车的速度
 7 
 8 void SolveDP()
 9 {
     l *= 60;    //因为最后求分钟，速度是小时每千米,先*60一样的
     r[0] = 0;
     
     int speed, weight;
     double time_best, time_now;
     
     for (int i = 1; i <= n; i++) {  //从1开始记录下标,r[0] = 0作为哨兵,便于程序统一处理
         
         scanf("%d%d", &(w[i]), &(s[i]));
         
         //第一种分组尝试,i单独一组
         weight = w[i];
         speed = s[i];
         time_best = 1000000; //max  TODO why need so large I thought 1000*60 will be OK since l < 1000 s > 1 ?? 
         
         //尝试其它所有可能的包含i的分组,注意速度没有下降则肯定更多车辆更优
         //因为s(i) <= s(j) when i < j ,因此只有速度下降时我们才计算一下到前面
         //速度对应的最优时间和已有的最优时间对比
         int j;
         for (j = i - 1; j && (weight += w[j]) <= b; j-- ){
             if (s[j] < speed) {
                 time_now = r[j] + (double)l / (double)speed;    //分组.j-1, j|| j + 1i
                 if (time_now < time_best)
                     time_best = time_now; 
                 speed = s[j];   // change group sppeed to the lower one
             }
         }
         
         time_now = r[j] + (double)l / (double)speed;    //still nedd to deal with the last
         
         if (time_now < time_best)
             r[i] = time_now;
         else
             r[i] = time_best;
     }
 
     printf("%.1f\n", r[n]);
 }
 
 int main(int argc, char *argv[])
 {
     while (1) {
         
         scanf("%d%d%d",&b, &l, &n);
         
         if (b == 0 && l ==0 && n ==0)
             break;
 
         SolveDP();
     }
     return 0;
 }

标程 

 1 #include <stdio.h>
 2 
 3 
 4 #define MAX_VEHICLES 1000
 5 
 6 typedef struct {
 7     int load;
 8     double total_time;
 9     double group_time;
 } Record_t;
 
 Record_t records[MAX_VEHICLES][MAX_VEHICLES + 1];
 
 int main(void) {
     int load, length, number, weight, speed, i, j, k;
     double min_time;
     
 for (;;)
  {
     scanf("%d%d%d", &load, &length, &number);
     if (!number) break;
     for (i = 0; i < number; ++i) {
         scanf("%d%d", &weight, &speed);
         if (i == 0) {
             records[0][0].load = weight;
             records[0][0].total_time = records[0][0].group_time = 60.0*length/speed;
             j = 1;
         } else {
             j = k = 0;
             min_time = records[i - 1][0].total_time;
             while (records[i - 1][k].load != 0) {
                 if (min_time > records[i - 1][k].total_time)
                     min_time = records[i - 1][k].total_time;
                 if (records[i - 1][k].load + weight <= load) {
                     records[i][j].load = records[i - 1][k].load + weight;
                     if (records[i - 1][k].group_time >= 60.0*length/speed) {
                         records[i][j].total_time = records[i - 1][k].total_time;
                         records[i][j].group_time = records[i - 1][k].group_time;
                     } else {
                         records[i][j].total_time = records[i - 1][k].total_time
                                 + 60.0*length/speed - records[i - 1][k].group_time;
                         records[i][j].group_time = 60.0*length/speed;
                     }
                     ++j;
                 }
                 ++k;
             }
             records[i][j].load = weight;
             records[i][j].total_time = min_time + 60.0*length/speed;
             records[i][j].group_time = 60.0*length/speed;
             ++j;
         }
         records[i][j].load = 0;
     }
     min_time = records[number - 1][0].total_time;
     i = 1;
     while (records[number - 1][i].load != 0) {
         if (records[number - 1][i].total_time < min_time)
             min_time = records[number - 1][i].total_time;
         ++i;
     }
     printf("%.1f\n", min_time);
  }
     return 0;