【蓝桥杯3.23 最大开支】（贪心+大根堆+优先队列）

大佬们写得都很详细（星星眼），友友们想细致学习的可以顺路去瞅瞅，本文只截取了比较重点的部分来完成本题

优先队列

在队列内部添加排序，本质是堆实现

top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾巴 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

priority_queue<Type,Container,Functional>
数据类型
数组实现的容器类型，vector（不能用list）
比较方式
//升序队列
priority_queue<int,vector<int>,greater<int>>q;
//降序队列
priority_queue<int,vector<int>,less<int>>q;

大顶堆

当前元素是r[i]
左孩子r[2*i+1]  右孩子r[2*i+2]  父亲r[(i-1)/2]

• 根据初始数组构造堆（调整父节点大于子节点）
• 每次交换第一个和最后一个元素，输出最大值，剩下的元素重新调整

void headAdjust(vector<int>&a,int parent,int length)
{
	int temp=a[parent];
	int lchild=2*parent+1;
	while(child<length)
	{
		if(child++<length&&a[child]<a[child++])
			child++;
	}
	if(temp>=a[child])
	{
		break;
	}
	else
	{
		a[parent]=a[child];
        parent=child;
        child=child*2+1;
     //以便在堆排序过程中正确地处理父节点与孩子节点之间的关系
	}
	a[parent]=temp;
	
}
void headSort(vector<int>&a)
{
	for(int i=a.size()/2;i>0;i--)
        headAdjust(a,i,a.size());
    for(int i=a.size()-1;i>0;i--)
    {
        int temp=a[i];
        a[i]=a[0];
        a[0]=temp;
        headAdjust(a,0,i);
    }
}
int main() {
    // 初始化整数向量
    std::vector<int> a = {1, 3, 4, 5, 2, 6, 9, 7, 8, 0};

    // 对向量a进行堆排序
    Heapsort(a);

    // 输出排序后的数组
    std::cout << "Sorted array: ";
    for (int i = 0; i < a.size(); i++) {
        std::cout << a[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}
//第一个循环是用来构建最大堆的，从中间位置向前遍历；第二个循环则是用来进行堆排序的，从数组末尾向前遍历。

【最大开支】

思路很新颖，找到增加的阈值相加求最大

#include <iostream>
#include<queue>
#define LL long long 
#define cir(i,a,b) for(int i=a;i<b;i++)
using namespace std;

const int I=1e5+5;
int k[I],b[I];
priority_queue<LL> q;//优先队列实现大根堆排序

LL addMoney(int x,int i)
{
     return max((k[i]*x+b[i])*x-(k[i]*(x-1)+b[i])*(x-1),0);
     //计算每增加一个人增加的开支
}

int main()
{
    LL n,m;
    cin>>n>>m;
    cir(i,0,m)
    {
        cin>>k[i]>>b[i];
    }
    cir(i,0,m)
    {
        cir(j,1,n+1)//
        {
            if(addMoney(j,i)>0)
            q.push(addMoney(j,i));
            else break;
        }
    }
    LL sum=0;
    int num=min(n,(LL)q.size());
    while(num>0)
    {
        sum+=q.top();
        q.pop();//弹出
        num--;
    }
    cout<<sum;

   
  // 请在此输入您的代码
  return 0;
}

两个循环外层对项目遍历，内层对人数遍历。每个人在选项目时都选择当下花费增加最多的项目，若项目i的门票价格为kx+b，那么增加的花费即addMoney函数。

可以用优先队列存项目的increase（当前项目人数增加为x+1所增加的花费），使increase最大的项目排在队首top，每加一个人出队一个并使总花费增加increase，即总花费money = money + increase(sum+=q.top())，更新x和increase，若increase > 0重新入队，若increase <= 0不重新入队(人数到了开口向下的二次函数的对称轴，花费开始下降，不能再增加人数了)

对于一个项目，人数并不是越多花费越多，题目中也提到了阈值。求解满足所有需求的最大花费，假设对项目p，有x个人选择去，当x*(kx+b) - (x-1)(k(x-1)+b) > 0说明x个人选择去项目j还没有达到阈值花费。

下面的例子可能数据不准确，不用纠结这些，主要看看运行过程，更好理解
int num=min(n,(LL)q.size())

n = 5
m = 3
k = [2, 3, 1]
b = [1, 2, 3]

1. 对于第一个商品（index = 0），可以计算出不同数量的购买对应的开支增加值：

   • 当购买数量 x = 1 时，开支增加值为：(k[0]*1+b[0])*1 - (k[0]*(1-1)+b[0])*(1-1) = (2*1+1)*1 - (2*(1-1)+1)*(1-1) = 3
   • 当购买数量 x = 2 时，开支增加值为：(k[0]*2+b[0])*2 - (k[0]*(2-1)+b[0])*(2-1) = (2*2+1)*2 - (2*(2-1)+1)*(2-1) = 9
   • 当购买数量 x = 3 时，开支增加值为：(k[0]*3+b[0])*3 - (k[0]*(3-1)+b[0])*(3-1) = (2*3+1)*3 - (2*(3-1)+1)*(3-1) = 21
   • 当购买数量 x = 4 时，开支增加值为：(k[0]*4+b[0])*4 - (k[0]*(4-1)+b[0])*(4-1) = (2*4+1)*4 - (2*(4-1)+1)*(4-1) = 37
   • 当购买数量 x = 5 时，开支增加值为：(k[0]*5+b[0])*5 - (k[0]*(5-1)+b[0])*(5-1) = (2*5+1)*5 - (2*(5-1)+1)*(5-1) = 57

   可以看到，在购买数量逐渐增加的情况下，开支增加值也在增加。

2. 对于第二个商品（index = 1），同样可以计算出不同数量的购买对应的开支增加值。

   • 当购买数量 x = 1 时，开支增加值为：(k[1]*1+b[1])*1 - (k[1]*(1-1)+b[1])*(1-1) = (3*1+2)*1 - (3*(1-1)+2)*(1-1) = 5
   • 当购买数量 x = 2 时，开支增加值为：(k[1]*2+b[1])*2 - (k[1]*(2-1)+b[1])*(2-1) = (3*2+2)*2 - (3*(2-1)+2)*(2-1) = 18
   • 当购买数量 x = 3 时，开支增加值为：(k[1]*3+b[1])*3 - (k[1]*(3-1)+b[1])*(3-1) = (3*3+2)*3 - (3*(3-1)+2)*(3-1) = 42
   • 当购买数量 x = 4 时，开支增加值为：(k[1]*4+b[1])*4 - (k[1]*(4-1)+b[1])*(4-1) = (3*4+2)*4 - (3*(4-1)+2)*(4-1) = 76
   • 当购买数量 x = 5 时，开支增加值为：(k[1]*5+b[1])*5 - (k[1]*(5-1)+b[1])*(5-1) = (3*5+2)*5 - (3*(5-1)+2)*(5-1) = 120

3. 对于第三个商品（index = 2），同样可以计算出不同数量的购买对应的开支增加值。

   • 当购买数量 x = 1 时，开支增加值为：(k[2]*1+b[2])*1 - (k[2]*(1-1)+b[2])*(1-1) = (1*1+3)*1 - (1*(1-1)+3)*(1-1) = 4
   • 当购买数量 x = 2 时，开支增加值为：(k[2]*2+b[2])*2 - (k[2]*(2-1)+b[2])*(2-1) = (1*2+3)*2 - (1*(2-1)+3)*(2-1) = 10
   • 当购买数量 x = 3 时，开支增加值为：(k[2]*3+b[2])*3 - (k[2]*(3-1)+b[2])*(3-1) = (1*3+3)*3 - (1*(3-1)+3)*(3-1) = 18
   • 当购买数量 x = 4 时，开支增加值为：(k[2]*4+b[2])*4 - (k[2]*(4-1)+b[2])*(4-1) = (1*4+3)*4 - (1*(4-1)+3)*(4-1) = 28
   • 当购买数量 x = 5 时，开支增加值为：(k[2]*5+b[2])*5 - (k[2]*(5-1)+b[2])*(5-1) = (1*5+3)*5 - (1*(5-1)+3)*(5-1) = 40

根据以上计算，我们可以得到每个商品在不同数量购买情况下的开支增加值。然后，将这些开支增加值按照从大到小的顺序放入优先队列 q 中。最后，从优先队列 q 中取出前 n 个开支增加值（只有n个人），并将它们累加到变量 sum 中。输出结果即为 sum 的值。