二分贪心--20

题目大概:

每个箱子能放6*6的大小的东西,分别有六种大小的物品,1*1..2*2..3*3...4*4。5*5  .6*6,问最少许雅io多少箱子。

思路:

高度不考虑了,只算大小。

1。。。6*6  一个占一个箱子。

2。。。5*5,占一个箱子在用1*1的补上空位。

3。。。4*4,占一个箱子,用2*2  1*1补位。

4。。。3*3,四个刚好一个箱子,当少于四个时,用2*2  1*1补位。

5。。。最后2*2  和1*1  直接计算有多少个箱子。

代码:

#include<iostream>
#include<cstdio>
using namespace std;
int b[7], cot;int main()
{

   while(1){
      for(int i=0;i<6;i++){
         scanf("%d",&b[i]);
      }
      int flag=0;
      for(int i=0;i<6;i++){
         if(b[i]==0) flag ++;
      }
      if(flag == 6) break;


      cot = 0;
      if(b[5] != 0){
         cot+=b[5];
      }

      if(b[4] != 0){
         cot+=b[4];
         int x = b[4]*11;
         b[0] = b[0]-x>=0?b[0]-x:0;
      }

      if(b[3] != 0){
         int res = 0;
         cot+=b[3];
         res = 20*b[3];
         if(b[1] != 0) {
            int x = b[1] / 5;
            if( x >= b[3]) { b[1] = b[1] - b[3]*5; res = 0; }
            else { res -= b[1]*4; b[1] = 0; }
         }
         if(b[0] != 0&& res != 0) {
            b[0] = b[0]>res?b[0]-res:0;
         }
      }

      if(b[2] != 0) {
         int x = b[2] / 4, y = b[2] % 4;
         int res = 0;
         cot += x;
         if(y != 0) cot++;
         if(y == 1){
            res = b[1] > 5?7:27-b[1]*4;
            b[1] = b[1] > 5? b[1]-5:0;
         }
         if(y == 2){
            res = b[1]>3? 6:18-b[1]*4;
            b[1] = b[1] > 3? b[1]-3:0;
         }
         if(y == 3){
            if(b[1] != 0) { res = 5; b[1] --; }
            else res = 9;
         }

         if(res != 0&&b[0] != 0) b[0] = b[0]>res?b[0]-res:0;
      }

      if(b[1] != 0){
         int y = b[1] % 9;
         cot += b[1]/9;
         if(y != 0) {
            cot++;
            y = 36 - y*4;
            b[0] = b[0]>y?b[0]-y:0;
         }
      }

      if(b[0] != 0) {
         cot += (b[0] / 36);
         b[0] %= 36;
         if(b[0] != 0) cot++;
      }

      printf("%d\n", cot);
   }
   return 0;
}


### 二分贪心算法结合使用的解决方案 在某些复杂问题中,可以将二分算法与贪心算法结合使用,以提高解决问题的效率和准确性。以下是关于如何结合这两种算法的一个示例。 #### 示例:分配任务问题 **问题描述**:有 $N$ 个任务需要分配给 $M$ 个人完成,每个人最多只能完成一个任务。每个任务有一个完成时间 $T_i$。目标是找到一种分配方式,使得所有任务完成的时间总和最小化。 **解决思路**: 1. **二分法的应用**:首先通过二分法确定一个可能的最大完成时间 $X$。假设每个人都不能超过这个最大完成时间 $X$。 2. **贪心法的应用**:对于固定的 $X$,使用贪心算法检查是否可以将所有任务分配给 $M$ 个人,并满足每个人的完成时间不超过 $X$。 **具体步骤**: - 使用二分法确定一个可能的最大完成时间 $X$ 的范围。初始时,设定左边界为任务中最短的完成时间,右边界为所有任务完成时间的总和。 - 对于每一个二分得到的中间值 $mid$,使用贪心算法判断是否可以在最大完成时间为 $mid$ 的条件下完成所有任务。 - 如果可以完成,则尝试更小的 $mid$;否则尝试更大的 $mid$。 #### 示例代码 以下是一个基于上述思路的 C++ 示例代码: ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; bool canAssign(vector<int>& tasks, int mid, int m) { int count = 1; // 当前需要的人数 int timeSum = 0; // 当前人的累计时间 for (int i = 0; i < tasks.size(); ++i) { if (timeSum + tasks[i] > mid) { // 超过当前限制 count++; timeSum = tasks[i]; if (count > m) return false; // 需要的人数超过限制 } else { timeSum += tasks[i]; } } return true; } int findMinTime(vector<int>& tasks, int m) { sort(tasks.begin(), tasks.end()); // 排序任务 int left = tasks[0]; // 最小的任务时间 int right = accumulate(tasks.begin(), tasks.end(), 0); // 所有任务时间总和 int result = right; while (left <= right) { int mid = (left + right) / 2; if (canAssign(tasks, mid, m)) { result = mid; right = mid - 1; // 尝试更小的值 } else { left = mid + 1; // 尝试更大的值 } } return result; } int main() { vector<int> tasks = {3, 5, 7, 10}; // 每个任务的完成时间 int m = 2; // 可用的人数 cout << "Minimum total time: " << findMinTime(tasks, m) << endl; return 0; } ``` #### 解释 - 在上述代码中,`canAssign` 函数用于检查是否可以在最大完成时间为 `mid` 的条件下完成所有任务[^1]。 - `findMinTime` 函数通过二分查找确定最小的总完成时间[^2]。 - 主函数中定义了任务列表和可用人数,并输出最小的总完成时间[^3]。 ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值