首 先 以 为 这 题 有 啥 单 调 性 的 , 硬 是 没 看 出 来 首先以为这题有啥单调性的,硬是没看出来 首先以为这题有啥单调性的,硬是没看出来
没 办 法 就 先 写 了 一 个 暴 力 , 就 发 现 可 以 优 化 了 没办法就先写了一个暴力,就发现可以优化了 没办法就先写了一个暴力,就发现可以优化了
首 先 可 以 将 枚 举 的 方 案 优 化 , 先 枚 举 区 间 长 度 x 首先可以将枚举的方案优化,先枚举区间长度x 首先可以将枚举的方案优化,先枚举区间长度x
看 一 下 数 据 范 围 可 以 发 现 , 值 域 并 不 是 很 大 , 设 最 大 为 y 看一下数据范围可以发现,值域并不是很大,设最大为y 看一下数据范围可以发现,值域并不是很大,设最大为y
那 么 这 个 答 案 的 范 围 就 是 [ 0 , y / x ] 那么这个答案的范围就是[0,y/x] 那么这个答案的范围就是[0,y/x]
这 样 可 以 将 数 组 排 序 , 先 枚 举 区 间 长 度 再 枚 举 值 的 可 能 , 直 接 在 原 序 列 里 面 二 分 答 案 即 可 这样可以将数组排序,先枚举区间长度再枚举值的可能,直接在原序列里面二分答案即可 这样可以将数组排序,先枚举区间长度再枚举值的可能,直接在原序列里面二分答案即可
很 显 然 前 面 两 个 循 环 时 间 复 杂 度 是 O ( n l n n ) , 时 间 复 杂 度 为 O ( n l o g n l n n ) ≈ O ( n l o g 2 n ) {很显然前面两个循环时间复杂度是O(nlnn),时间复杂度为O(nlognlnn)\approx O(nlog^2n)} 很显然前面两个循环时间复杂度是O(nlnn),时间复杂度为O(nlognlnn)≈O(nlog2n)
但 是 这 个 还 是 过 不 了 , 而 且 最 大 的 时 间 跑 了 10 s . . . . . . 但是这个还是过不了,而且最大的时间跑了10s...... 但是这个还是过不了,而且最大的时间跑了10s......
发 现 值 域 是 较 小 的 范 围 , 可 以 在 桶 里 面 求 前 缀 和 做 , 时 间 复 杂 度 ( n l o g n ) 发现值域是较小的范围,可以在桶里面求前缀和做,时间复杂度(nlogn) 发现值域是较小的范围,可以在桶里面求前缀和做,时间复杂度(nlogn)
突然发现logn好废
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int read(){
int num=0;bool flag=1;
char c=getchar();
for(;c<'0'||c>'9';c=getchar())
if(c=='-')flag=0;
for(;c>='0'&&c<='9';c=getchar())
num=(num<<1)+(num<<3)+c-'0';
return flag?num:-num;
}
#define ll long long
int n,a[N],Max,c[N];ll sum,ans;
int main()
{
n=read();
for(int i=1;i<=n;i++){
a[i]=read();
Max=max(Max,a[i]);
sum+=a[i];c[a[i]]++;
}ans=sum;
for(int i=1;i<=Max;i++)c[i]+=c[i-1];
for(int i=2;i<=Max;i++){
ll now=sum;int lft=0;
for(int j=0;j<=Max/i;j++){
int rgh=min(Max,(j+1)*i-1);
// int rgh=lower_bound(a+lft+1,a+n+1,(j+1)*i)-a-1;
now-=1ll*(c[rgh]-c[lft])*(i-1)*j;lft=rgh;
}
ans=min(ans,now);
}
printf("%lld",ans);return 0;
}