题目大意

有两个长度为$n$的序列$a,b$，这两个序列都是单调不降的。

你可以对$a$进行不超过$m$次操作，每次操作你可以选择一个$i$满足$1\le i\le n$，然后选择一个整数（可以是负数）$x$，将$a_i$加上$x$，这次操作要花费$x^2$的代价。

在操作的过程中，你需要保证$a$始终单调不降。

最后，你需要将$a$序列变为$b$序列，即对任意$i$满足$1\le i\le n$，都有$a_i=b_i$。

求需要花费的总代价的最小值。输出答案模$998244353$后的值。如果不可能让$a$序列变为$b$序列，则输出$-1$。

$1\le n,m\le 10^5,0\le a_i,b_i\le 10^9$

题解

首先，我们可以对每个值不等于$b_i$的$a_i$都加上$b_i-a_i$。我们发现，对于相邻的两个位置，我们可以规定一个修改的先后顺序以满足在修改的时候这两个位置始终保持前一个位置的$a$值不超过后一个位置的$a$值。那么，因为这些先后顺序不会有环，所以这样是可以保证$a$始终单调不降的。

我们按上面的方法操作，如果操作次数不够就输出$-1$。

如果还剩下一些操作次数，则我们可以用这些操作次数来减少代价。

根据基本不等式，我们将一个$+x$尽量平均地分成多次加法能使代价最少。那么，对于每个位置要加的$x$，我们记录它当前被拆成了多少份，设拆成了$k$份，我们求出将其拆成$k+1$份相比于$k$份能将代价减少多少。一开始每种操作都可以看作被拆成一份，我们以减少的代价为关键字来将这些操作放在大根堆里，每次取出堆顶并将代价减少对应的量，然后更新这次操作被拆成的数$k$，即令$k=k+1$，然后继续算出将其拆成$k+1$份相比于$k$份能将代价减少多少并放入堆中，这样将剩下的操作都用完，即可得出答案。

时间复杂度为$O((n+m)\log n)$。

code

#include<bits/stdc++.h>
using namespace std;
const int N=100000;
const long long mod=998244353;
int n,m;
long long ans=0,a[N+5],b[N+5];
struct node{long long x,k,v;bool operator<(const node ax)const{return v<ax.v;}
};
priority_queue<node>q;
long long dv(long long x,long long k){return (x/k)*(x/k)*(k-x%k)+(x/k+1)*(x/k+1)*(x%k);
}
long long gt(long long x,long long k){return dv(x,k)-dv(x,k+1);
}
int main()
{
//	freopen("attend.in","r",stdin);
//	freopen("attend.out","w",stdout);scanf("%d%d",&n,&m);for(int i=1;i<=n;i++) scanf("%lld",&a[i]);for(int i=1;i<=n;i++) scanf("%lld",&b[i]);for(int i=1;i<=n;i++){if(a[i]!=b[i]){--m;ans=(ans+(a[i]-b[i])*(a[i]-b[i])%mod)%mod;q.push((node){abs(a[i]-b[i]),1,gt(abs(a[i]-b[i]),1)});}}if(m<0){printf("-1");return 0;}if(q.empty()){printf("%lld",ans);return 0;}while(m--){node t=q.top();q.pop();ans=(ans-t.v%mod+mod)%mod;q.push((node){t.x,t.k+1,gt(t.x,t.k+1)});}printf("%lld",ans);return 0;
}