二分贪心 T - 20

部署运行你感兴趣的模型镜像

Description

A factory produces products packed in square packets of the same height h and of the sizes 1*1, 2*2, 3*3, 4*4, 5*5, 6*6. These products are always delivered to customers in the square parcels of the same height h as the products have and of the size 6*6. Because of the expenses it is the interest of the factory as well as of the customer to minimize the number of parcels necessary to deliver the ordered products from the factory to the customer. A good program solving the problem of finding the minimal number of parcels necessary to deliver the given products according to an order would save a lot of money. You are asked to make such a program.

Input

The input file consists of several lines specifying orders. Each line specifies one order. Orders are described by six integers separated by one space representing successively the number of packets of individual size from the smallest size 1*1 to the biggest size 6*6. The end of the input file is indicated by the line containing six zeros.

Output

The output file contains one line for each line in the input file. This line contains the minimal number of parcels into which the order from the corresponding line of the input file can be packed. There is no line in the output file corresponding to the last ``null'' line of the input file.

Sample Input

0 0 4 0 0 1 
7 5 1 0 0 0 
0 0 0 0 0 0 

Sample Output

2 
1 


        这道题的基本题意为有1*1,2*2,3*3,4*4,5*5,6*6的产品用6*6的盒子装,要求求需要的最少盒子数。

       思路为先装大的产品,6*6的只能装一个,不能装其他的;5*5的也只能装一个,还可以装11个1*1的;4*4的也只能装一个,还可以装5个2*2的,2*2的不够用1*1的补上;3*3的可以装1、2、3、4个,4个的时候刚好装满,3个的时候还能装1个2*2的跟5个1*1的,2个时候可以装3个2*2的跟6个1*1的,1个的时候可以装5个2*2的跟7个1*1的;2*2的每9个刚好装满,余下的用1*1的补装。基本贪心思路为这样。


源代码如下:

#include<iostream>
#include<cstring>
using namespace std;
int main()
{ int a[7],i,m;
 while(cin>>a[1]>>a[2]>>a[3]>>a[4]>>a[5]>>a[6])
 { 
   m=0;
  if(a[1]==0&&a[2]==0&&a[3]==0&&a[4]==0&&a[5]==0&&a[6]==0)break;
   m+=a[6];
   
   m+=a[5];
   a[1]-=a[5]*11;
   
   m+=a[4];
   a[2]-=a[4]*5;
   if(a[2]<0)
   {
     a[1]+=a[2]*4;
     a[2]=0;
   }
   
   if(a[3]%4==0)m+=a[3]/4;
   else {
         m+=a[3]/4+1;
        if(a[2]>=0)
         { if(a[3]%4==1)
		  { a[2]-=5;
		    a[1]-=7;
	      }
           if(a[3]%4==2)
		   {
		   a[2]-=3;
		   a[1]-=6;
	       }
           if(a[3]%4==3)
		   { a[2]-=1;
	         a[1]-=5;
		   }
         }
        if(a[2]<0)
		{
         a[1]+=a[2]*4;
         a[2]=0;
        }
        }
        
   if(a[2]%9==0)m+=a[2]/9;
   else 
   {
       m+=a[2]/9+1;
       a[1]-=36-(a[2]%9)*4;
    }
    
   if(a[1]>0)
    if(a[1]%36==0)m+=a[1]/36;
   else m+=a[1]/36+1;
   cout<<m<<endl;
 }
} 


   

您可能感兴趣的与本文相关的镜像

Llama Factory

Llama Factory

模型微调
LLama-Factory

LLaMA Factory 是一个简单易用且高效的大型语言模型(Large Language Model)训练与微调平台。通过 LLaMA Factory,可以在无需编写任何代码的前提下,在本地完成上百种预训练模型的微调

### 二分贪心算法结合使用的解决方案 在某些复杂问题中,可以将二分算法贪心算法结合使用,以提高解决问题的效率和准确性。以下是关于如何结合这两种算法的一个示例。 #### 示例:分配任务问题 **问题描述**:有 $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、付费专栏及课程。

余额充值