CF1428 E. Carrots for Rabbits 贪心+优先队列

n个数切成k份,求切出数的平方和的最小值.

有个比较显然的结论：

对于一个数x，把它分成y份，求平方和sm，使得sm最小的分法一定是均分。

而把一个数分成y份，平方和与分成y-1份的平方和减量设为Cy，分成z份，平方和与分成z-1份的平方和减量设为Cz。显然有：if(y<z)则Cy>Cz。

这里说明了我们可以贪心的分萝卜，当前最优一定是全局最优，因为后面的分块一定不优于当前分块sm的减量。

于是便有了贪心：

刚开始n个数，还需要分出k-n块。

我们把每个数存到优先队列里，优先队列存：这个数已经被分了num份，这个数分成num份后的sum：now，这个数分成num+1份后的sum：nxt。

这个数的id。其中优先队列nxt-now 排序，大的值在前面。

这样每次选择都是让sum减少最多的情况，而且后面每次减量递减，也就是当前最大同时也是全局最大。所以可以贪心！

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define re register
#define ls (o<<1)
#define rs (o<<1|1)
//#define m (l+r)/2
#define pb push_back
typedef pair<int,int> pii;
const double PI= acos(-1.0);
const int M = 1e5+7;
/*
int head[M],cnt=1;
void init(int n){cnt=1;for(int i=0;i<=n;i++)head[i]=0;}
struct EDGE{int to,nxt,w;}ee[M*2];
void add(int x,int y,int w){ee[++cnt].nxt=head[x],ee[cnt].w=w,ee[cnt].to=y,head[x]=cnt;}
*/
ll a[M];
/*
每次分胡萝卜，减少的sum是逐渐递减的 
*/
struct node{
	ll val;//如果再分一次，减少的sum 
	ll now;//当前胡萝卜不分对sum的贡献 
	ll nxt;//把当前胡萝卜再分一次后对sum的贡献 
	int id;
	int num;//当前已经分了几次
	bool operator <(const node &r)const{
		return val<r.val;
	}
};
priority_queue<node>q; 
ll gao(int id,int num){//对第id个胡萝卜再次分块，分成num+1块，对sum的贡献 
	if(num>=a[id])return 1e18;
	num++;
	ll em=a[id]/num;//平均每个胡萝卜大小是em 
	int z=a[id]%num;//最后有z个胡萝卜大小是em+1
	ll ans=0;
	for(int i=1;i<=z;i++) ans+=(em+1)*(em+1);
	for(int i=z+1;i<=num;i++)ans+=em*em;
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
  	cin.tie(0);
  	int n,k;
  	cin>>n>>k;
  	ll ans=0;
  	for(int i=1;i<=n;i++){
  		cin>>a[i];
		ll now=a[i]*a[i];
		ll nxt=gao(i,1);
	//	cout<<i<<"   -  "<<now<<"  "<<nxt<<endl;
		q.push(node{now-nxt,now,nxt,i,1});
		ans+=now;
	}
	
	int num = k-n;
//	cout<<ans<<endl;
	while(num--){
		node tp=q.top();q.pop();
		ans-=tp.val;
	//	cout<<tp.id<<"  - > "<<tp.val<<endl;
		ll nxt=gao(tp.id,tp.num+1);
		q.push(node{tp.nxt-nxt,tp.nxt,nxt,tp.id,tp.num+1});
	}
	cout<<ans<<endl;
	return 0;
}