poj1017（1）

本文问题分析部分参考了http://blog.csdn.net/lyy289065406/article/details/6674366

大致题意：

一个工厂制造的产品形状都是长方体盒子，它们的高度都是 h，长和宽都相等，一共有六个型号，分别为1*1, 2*2, 3*3, 4*4, 5*5, 6*6。

这些产品通常使用一个 6*6*h 的长方体箱子包装然后邮寄给客户。因为邮费很贵，所以工厂要想方设法的减小每个订单运送时的箱子数量BoxNum。

 

解题思路：

由于盒子和箱子的高均为h，因此只需考虑底面积的空间。

 

6*6的盒子，每个盒子独占一个箱子。

5*5的盒子，每个盒子放入一个箱子，该箱子的剩余空间允许放入的最大尺寸为1*1，且最多放11个。

4*4的盒子，每个盒子放入一个箱子，该箱子的剩余空间允许放入的最大尺寸为2*2。

3*3的盒子，每4个刚好独占一个箱子，不足4个3*3的，剩下空间由2*2和1*2填充。

2*2的盒子和1*1的盒子主要用于填充其他箱子的剩余空间，填充后的多余部分才开辟新箱子装填。

 

package com.njupt.acm;

import java.util.Scanner;


 public class POJ1017 {


     int a;
     int b;
     int c;
     int d;
     int e;
     int f;
     int packets;
     int t;


     public POJ1017() {
         Scanner scan = new Scanner(System.in);
         a = scan.nextInt();
         b = scan.nextInt();
         c = scan.nextInt();
         d = scan.nextInt();
         e = scan.nextInt();
         f = scan.nextInt();
         while (a != 0 || b != 0 || c != 0 || d != 0 || e != 0 || f != 0) {
             // 6*6
             packets = f;
             
             // 5*5
             packets += e;
             a -= 11 * e;
             
             // 4*4
             packets += d;
             
             /**
              * 对于5 * d的理解:一个4*4大小的和盒子装进箱子以后,
              * 剩余的空间能装5个2*2大小的盒子。
              * 所以,d个4*4盒子装进箱子以后剩余的空间能装5*d个2*2的箱子
              * 
              */
             if (b >= 5 * d) {//如果2*2的箱子的数量b>=剩余空间所能容纳的2*2的箱子的数量
                 b -= 5 * d;//则消去已放进剩余空间的部分
             } else {
            //计算剩余空间在装满2*2的箱子以后所剩的空间还能容纳多少个2*2的盒子
                 t = 5 * d - b;
                 
                 //这是没装箱的2*2的盒子的数量记为0
                 b = 0;
                 
                 //消去装进剩余空间的部分
                 a -= 4*t;
             }
             
             
             // 3*3
             packets += c / 4;
             
             //计算还有多少个3*3的箱子未装箱(其数量肯定<4)
             t = c % 4;
             
             if (t != 0) {//如果未装箱的3*3的盒子数量>0
                 
            //将需要的箱子的数量+1
            packets += 1;
             
             
                 if (t == 1) {//如果未装箱巅峰3*3盒子的数量为1
                    
                /**
                 * 这时候的 情况如下：
                 * 
                 */
                if (b >= 5) {//如果未装箱的2*2盒子的数量>=5
                         b -= 5;//将未装箱的2*2盒子的数量-5
                         a -= 7;//将未装箱的1*1盒子的数量-7
                         
                     } else if (b >= 0) {//如果未装箱的2*2盒子的数量>=0
                         a -= (36 - 9 - 4 * b);//则将未装箱的2*2盒子全都装进去,且剩余空间都用1*1盒子填满
                         b = 0;//将未装箱的2*2盒子的数量置为0
                     }
                 
                 
                 } else if (t == 2) {//如果剩余未装箱的3*3的盒子的数量为2
                     
                if (b >= 3) {//如果未装箱的2*2盒子的数量>=3
                         b -= 3;//将未装箱的2*2的盒子数量-3
                         a -= 6;//将未装箱的1*1的盒子数量-6
                     
                } else if (b >= 0) {//如果未装箱的2*2的盒子数量0<=b<3
                         
                a -= (36 - 18 - 4 * b);
                         b = 0;//将未装箱的2*2的盒子的数量置为0.(实际上就是将剩下的2*2的盒子放进剩余空间里)
                     }
                 
                 
                 } else if (t == 3) {//如果剩余未装箱的3*3的和字数为3
                     
                if (b >= 1) {//如果剩余的未装箱的2*2盒子的数量>=1
                         b -= 1;//将未装箱的2*2的盒子数-1
                         a -= 5;//将未装箱的1*1的盒子数-5
                     
                } else if (b >= 0) {//假如没有未装箱的2*2盒子
                         a -= (36 - 27 - 4 * b);//实际上就是将未装箱的1*1盒子的数量-9
                         b = 0;//将未装箱的2*2盒子的数量置为0
                     }
                 }
             }
             
             // 2*2
             if (b > 0) {//如果未装箱的2*2的盒子数>0
                 
            //计算到目前为止的2*2的盒子还能装多少个箱子
            packets += b / 9;
                 
            //计算到现在还剩多少个2*2盒子未装箱
                 t = b % 9;
                 
                 if (t != 0){//如果未装箱的2*2盒子的数量 != 0 
                     
                packets += 1;//将需要用到的箱子数+1
                     a -= 36 - 4 * t;//将未装箱的1*1盒子数-响应数目
                 }
             }
             
             // 1*1
             if (a > 0) {
             
            //计算目前的剩下的1*1盒子还能装多少个箱子
                 packets += a / 36;
                 
                 //计算到现在还剩下多少个1*1盒子
                 t = a % 36;
                 
                 if (t != 0) {//如果剩下的1*1盒子数量!=0
                     packets += 1;//将需要用到的箱子的数量+1
                 }
             }
             System.out.println(packets);
             a = scan.nextInt();
             b = scan.nextInt();
             c = scan.nextInt();
             d = scan.nextInt();
             e = scan.nextInt();
             f = scan.nextInt();
         }
     }


     public static void main(String[] args) {
         new POJ1017();
     }
}