暑期第4周解题报告5篇（8月2日-8月8日）

/**
题目：
牛客2021-8-2
牛客多校训练营6
F Hamburger Steak

题意：
有n个汉堡和m个锅，每个汉堡需要煎的时间为ti
一个汉堡可以在一个锅中煎，也可以分成两次在两个锅中煎 
一个汉堡同时只能放到一个中
求一个方案使得煎好所有的汉堡所需要的时间最少 
  
思路:
假设我们知道了最小耗时t,就可以贪心地对每个锅的时间t依次分配给每个汉堡
当前这个锅没煎完的部分再由下个锅煎即可
我们需要保证所有的锅的时间和大于等于所有汉堡的时间
并且耗时最长的汉堡不会再统一时刻分到两个锅中
因此最小耗时t=max{max{ti},向上取整(sum(ti)/m)}
 
**/ 
#include<iostream>
#include<algorithm>
#define int long long
typedef long long ll; 
using namespace std;
const int N=1e5+5;
int a[N];
signed main()
{
	int n,m;
	cin >> n >> m;
	int sum=0;
	int ma=0;
	for(int i=1;i<=n;i++){
		cin >> a[i];
		sum=sum+a[i];//总时间 
		ma=max(ma,a[i]);//最大值 
	}
	int ans=max(ma,sum/m+(sum%m!=0));//最小耗时 
	int lef=ans;
	int cnt=1;
	for(int i=1;i<=n;i++){
		if(lef>=a[i]){
			cout << 1 << " " << cnt << " " << ans-lef << " " << ans-lef+a[i] << endl;
			lef=lef-a[i];
			if(!lef){
				lef=ans;
				cnt++;
			}
		}
		else{
			cout << 2 << " " << cnt+1 << " " << 0 << " " << a[i]-lef << " " << cnt << " " << ans-lef << " " << ans <<endl; 
			cnt++;
			lef=ans-(a[i]-lef);
		}
	}
	return 0;
}

/**
题目：
acwing
算法提高课 
166 数独 

题意：
需要把一个 9×9 的数独补充完整
使得图中每行、每列、每个 3×3 的九宫格内数字 1～9 均恰好出现一次
给出81个字符，代表数独的 81个格内数据
每个字符都是一个数字（1-9）或一个.(表示尚未填充） 
  
思路:
把行列九宫格的三种状态转换成三个九位的二进制数
其中1代表可以选 
只需要三个数字与一下，为1，就代表这个数字可以选 
选择从可选数字最少的状态开始，这样可以保证分支最少 

**/ 
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
 
const int N=9;
const int M=1<<N;
int map[M];
int ones[M];//当前这种状态中有几个1 
int row[N];//行 
int col[N];//列 
int cell[3][3];//九宫格 
char str[100];

void init(){
	for(int i=0;i<N;i++){
		row[i]=col[i]=(1<<N)-1;//二进制为111111111,表示每一个数都可以选 
	}
	for(int i=0;i<3;i++){
		for(int j=0;j<3;j++){
			cell[i][j]=(1<<N)-1; 
		}
	} 
}

int lowbit(int x){
    return x & (-x);
}

int get(int x, int y){
    return row[x] & col[y] & cell[x / 3][y / 3];
}

void draw(int x,int y,int t,bool is_set){//在x,y这个位置将数x填上还是删去 
	if(is_set){//填 
		str[x*N+y]='1'+t;//t的范围是0-8 
	}
	else{
		str[x*N+y]='.';
	}
	int v=1<<t;
	if(!is_set){//删 
		v=-v;
	}
	row[x]-=v;
	col[y]-=v;
	cell[x/3][y/3]-=v;
}

bool dfs(int cnt){
	if(!cnt){//没有空格了，找到了一种方案 
		return true;
	}
	int minv=10;
	int x,y;
	for(int i=0;i<N;i++){
		for(int j=0;j<N;j++){
			if(str[i*N+j]=='.'){
				int state=get(i,j);//行列九宫格并集之后的状态 
				if(ones[state]<minv){//选一个1的数量最少的，这样可以保证分支最少 
					minv=ones[state];
					x=i;
					y=j;
				}
			}
		} 
	} 
	int state=get(x,y);
	for (int i=state;i;i=i-lowbit(i)){
        int t = map[lowbit(i)];
        draw(x, y, t, true);
        if (dfs(cnt - 1)){
        	return true;	
		}
        draw(x, y, t, false);
    }
    return false;
}

int main()
{
	for(int i=0;i<N;i++){
		map[1<<i]=i;
	}
	for(int i=0;i<M;i++){
		for(int j=0;j<N;j++){
			ones[i]+=(i>>j) &1;//每个二进制数有多少个1 
		}
	}
	while(cin >> str && str[0]!='e'){
		init();
		int cnt=0;//有多少个空位 
		int k=0;
		for(int i=0;i<N;i++){
			for(int j=0;j<N;j++){
				if(str[k]!='.'){
					int t=str[k]-'1';
					draw(i,j,t,true);
				}
				else{
					cnt++;
				}
				k++;
			}
		}
		dfs(cnt);
		puts(str);
	}
	return 0;
 } 

/**
题目：
acwing
算法提高课 
168 生日蛋糕 

题意：
制作一个体积为 Nπ的M层生日蛋糕
要求从低到上依次半径越来越小 高度越来越小
我们希望蛋糕外表面（最下一层的下底面除外）的面积 Q 最小。
求出面积 
  
思路:
这里的面积包括每一层圆柱的侧面积和以最下面一层为半径的圆的面积
层间：从下到上
层内：先枚举半径再枚举高（半径相对于高来说对体积的影响较大），半径由大到小，高度由大到小 
可以根据关系得知每一层r和h的最大值和最小值
预处理前i层的体积和面积最小值来剪枝 
**/ 
#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
const int N=25;
int minv[N],mins[N];
int R[N],H[N];
int n,m; 
int ans=0x3f3f3f3f; 

void dfs(int u,int v,int s){
	if(v+minv[u]>n) return;
	if(s+mins[u]>=ans) return;
	if(s+2*(n-v)/R[u+1]>=ans) return;//数学公式推出来的剪枝 
	if(!u){
		if(v==n){
			ans=s;
		}
		return;
	}
	//先r后h,从大到小，确保搜索分支尽可能小 
	//界限剪枝 
	for(int r=min(R[u+1]-1,(int)(sqrt(n-v)));r>=u;r--){
		for(int h=min(H[u+1]-1,((n-v)/(r*r)));h>=u;h--){
			int t=0;
			if(u==m){//最底层 
				t=r*r; //加上最上面的面积 
			} 
			R[u]=r;
			H[u]=h;
			//递归到下一层 
			dfs(u-1,v+r*r*h,s+2*r*h+t); 
		}
	}
}

int main()
{
	cin >> n >> m;
	for(int i=1;i<=m;i++){
		minv[i]=minv[i-1]+i*i*i;//pi*r^2*h 每层最小体积 
		mins[i]=mins[i-1]+2*i*i;//2*pi*r*h 每层最小面积 
	}
	R[m+1]=0x3f3f3f3f;
	H[m+1]=0x3f3f3f3f;
	dfs(m,0,0);
	if(ans==0x3f3f3f3f) ans=0;
	cout << ans << endl;
	return 0;
 } 

/**
题目：
acwing
算法提高课 
167 木棒

题意：
一组等长的木棒随机砍断
要恢复，但不知道初始有多少木棒以及木棒的初始长度
求木棒可能的最小长度 
  
思路:
按木棒长度从小到大枚举，且只有sum % len == 0 时，长度才是有效的
优化搜索顺序，减少分支，从大到小枚举
排除等效冗余
3-1 如果当前木棍加到当前木棒中失败了， 则直接跳过后面所有长度相等的木棍
3-2 如果木棒的第一根木棍失败， 则一定失败
3-3 如果木棒的最后一根木棍失败， 则一定失败.
**/ 
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int N=70;
int a[N];
int n,sum,len;
int vis[N];
bool cmp(int x,int y){
	return x>y;
}
bool dfs(int x,int g,int st){//当前大的长度 大的是第几个 从小的哪一个开始 
	if(g*len==sum){//全部放完 
		return true;
	}
	if(x==len){//当前这个大的放完 
		return dfs(0,g+1,1);//下一个大的 
	}
	for(int i=st;i<=n;i++){//枚举小的里面没有放过的 
		if(vis[i]){//已经放过的就不要了 
			continue;
		}
		if(x+a[i]>len){//这个小的放进去以后长度超了 也不要 
			continue;
		}
		vis[i]=1;//找到了一个满足的 
		if(dfs(x+a[i],g,i+1)){
			return true;
		}
		vis[i]=0;
		//第一个根就失败，接下来的空大棒的第一根都会失败 
		if(!x){
			return false;
		}
		//最后一根放入后长度满足，但是接下来失败，则失败 
		if(x+a[i]==len){
			return false;
		}
		//搜索失败，不再尝试拼相同长度的，因为会必然失败 
		int j=i;
		while(j<=n && a[j]==a[i]){
			j++;
		}
		i=j-1;
	} 
	return false;
}
int main()
{
	while(cin >> n && n){
		memset(vis,0,sizeof(vis));
		sum=0;
		for(int i=1;i<=n;i++){
			cin >> a[i];
			sum=sum+a[i];
		}
		//从大到小排序 
		sort(a+1,a+1+n,cmp);
		len=1;
		while(1){
			if(sum%len==0 && dfs(0,1,1)){
				cout << len << endl;
				break;
			}
			len++;
		}
	}
	return 0;
 } 

/**
题目：
acwing
算法提高课 
1118 分成互质组

题意：
给定 n 个正整数，将它们分组，使得每组中任意两个数互质。
至少要分成多少个组？
  
思路:
一组一组的考虑，依次考察所有没有分到某组的数据
如果一个数据能放入当前考察的组，则直接放入
如果当前组不能放入任何一个数据了，那么新开一组
**/ 
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int N=70;
int a[N];
int n,sum,len;
int vis[N];
bool cmp(int x,int y){
	return x>y;
}
bool dfs(int x,int g,int st){//当前大的长度 大的是第几个 从小的哪一个开始 
	if(g*len==sum){//全部放完 
		return true;
	}
	if(x==len){//当前这个大的放完 
		return dfs(0,g+1,1);//下一个大的 
	}
	for(int i=st;i<=n;i++){//枚举小的里面没有放过的 
		if(vis[i]){//已经放过的就不要了 
			continue;
		}
		if(x+a[i]>len){//这个小的放进去以后长度超了 也不要 
			continue;
		}
		vis[i]=1;//找到了一个满足的 
		if(dfs(x+a[i],g,i+1)){
			return true;
		}
		vis[i]=0;
		//第一个根就失败，接下来的空大棒的第一根都会失败 
		if(!x){
			return false;
		}
		//最后一根放入后长度满足，但是接下来失败，则失败 
		if(x+a[i]==len){
			return false;
		}
		//搜索失败，不再尝试拼相同长度的，因为会必然失败 
		int j=i;
		while(j<=n && a[j]==a[i]){
			j++;
		}
		i=j-1;
	} 
	return false;
}
int main()
{
	while(cin >> n && n){
		memset(vis,0,sizeof(vis));
		sum=0;
		for(int i=1;i<=n;i++){
			cin >> a[i];
			sum=sum+a[i];
		}
		//从大到小排序 
		sort(a+1,a+1+n,cmp);
		len=1;
		while(1){
			if(sum%len==0 && dfs(0,1,1)){
				cout << len << endl;
				break;
			}
			len++;
		}
	}
	return 0;
 }