校招算法笔面试 | 校招笔面试真题-小红的数组操作

题目## 题目

题目链接

题目链接

小红的数组操作

题目描述

小红拿到了一个数组，她准备对这个数组进行如下两种操作：

1. 删除数组的第一个元素。该操作的花费为 $x$。
2. 使得数组中任意一个元素加 1 或者减 1。该操作的花费为 $y$。

小红希望用尽可能少的花费使得数组所有元素都相等，请你帮小红求出最小的花费。

输入:

• 第一行输入三个正整数 $n$、$x$、$y$，代表数组的大小以及两种操作的花费
• 第二行输入 $n$ 个正整数，代表数组的元素

输出:

• 输出一个整数，代表将所有元素变成相等的最小总花费

解题思路

这是一个动态查询问题，可以通过以下步骤解决：

1. 关键发现：

   • 对于每个子数组，最优的目标值是中位数
   • 需要动态维护元素个数和元素和
   • 需要能快速查询第k大的元素

2. 解题策略：

   • 使用树状数组维护元素个数和元素和
   • 离散化处理数组元素
   • 使用二分查找第k大的元素

3. 具体步骤：

   • 对数组元素进行离散化处理
   • 使用两个树状数组分别维护个数和元素和
   • 依次删除前缀，计算每种情况的代价

---

代码

#include <iostream>
#include <vector>
#include <map>
using namespace std;
using ll=long long;
const int N=100100;
int a[N];
int n;
ll x,y;
struct BIT{
	vector<ll> tr1;
	int n;
	
	BIT(int n=200100):n(n),tr1(n+5){}
	
	void add(int now,ll val){
		for(int i=now;i<=n;i+=i&-i){
			tr1[i]+=val;
		}
	}
	
	ll query(int now){
		ll res=0;
		for(int i=now;i>0;i-=i&-i)
			res+=tr1[i];
		return res;
	}
	
	ll query(int l,int r){
		return query(r)-query(l-1);
	}
	
	int kth(int k){
		int ans=0,res=0;
		for(int i=1<<__lg(n);i>0;i>>=1){
			ans+=i;
			if(ans<n&&res+tr1[ans]<k)
				res+=tr1[ans];
			else
				ans-=i;
		}
		return ans+1;
	}
};

map<int,int> ls;
int sl[N];
int ls_cnt=0;
void init()
{
	for(int i=1;i<=n;++i)
		ls[a[i]]=0;
	for(auto &p:ls)
	{
		p.second=++ls_cnt;
		sl[ls_cnt]=p.first;
	}
}

int main(void)
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	__int128_t ans=9e18,r1,r2,r3;
	int i,idx;
	cin>>n>>x>>y;
	for(i=1;i<=n;++i)
		cin>>a[i];
	init();
	BIT cnt(n+5),num(n+5);
	for(i=1;i<=n;++i)
	{
		cnt.add(ls[a[i]],1);
		num.add(ls[a[i]],a[i]);
	}
	for(i=1;i<=n;++i)
	{
		idx=cnt.kth((n-i)/2+1);
		r1=cnt.query(1,idx)*sl[idx]-num.query(1,idx);
		r2=num.query(idx,n)-cnt.query(idx,n)*sl[idx];
		r3=i-1;
		ans=min(ans,r1*y+r2*y+r3*x);
		cnt.add(ls[a[i]],-1);
		num.add(ls[a[i]],-a[i]);
	}
	cout<<(ll)ans;
	return 0;
}

import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class Main {
   
   
    static class BIT {
   
   
        long[] tree;
        int n;
        
        BIT(int n) {
   
   
            this.n = n;
            tree = new long[n + 5];
        }
        
        void add(int pos, long val) {
   
   
            for(int i = pos; i <= n; i += i & -i) {
   
   
                tree[i] += val;
            }
        }
        
        long query(int pos) {
   
   
            long res = 0;
            for(int i = pos; i > 0; i -= i & -i) {
   
   
                res += tree[i];
            }
            return res;
        }
        
        long query(int l, int r) {
   
   
            return query(r) - query(l - 1);
        }
        
        int kth(int k) {
   
   
            int ans = 0, res = 0;
            for(int i = 1 << (31 - Integer.numberOfLeadingZeros(n)); i > 0; i >>= 1) {
   
   
                ans += i;
                if(ans < n && res + tree[ans] < k) {
   
   
                    res += tree[ans]