[蓝桥杯 2021 省 AB2] 负载均衡

一.题目

题目描述

有 n 台计算机，第 i 台计算机的运算能力为 $v_i$。

有一系列的任务被指派到各个计算机上，第 i 个任务在 $a_i$ 时刻分配，指定计算机编号为 $b_i$，耗时为 $c_i$ 且算力消耗为 $d_i$。

如果此任务成功分配，将立刻开始运行，期间持续占用 $b_i$ 号计算机 $d_i$ 的算力，持续 $c_i$ 秒。

对于每次任务分配，如果计算机剩余的运算能力不足则输出 −1，并取消这次分配，否则输出分配完这个任务后这台计算机的剩余运算能力。

输入格式

输入的第一行包含两个整数 n,m，分别表示计算机数目和要分配的任务数。

第二行包含 n 个整数 $v_1,v_2,\cdot \cdot \cdot v_n$，分别表示每个计算机的运算能力。

接下来 m 行每行 4 个整数 $a_i,b_i,c_i,d_i$，意义如上所述。数据保证 $a_i$ 严格递增，即 $a_i$ < $a_i$ + 1。

输出格式

输出 m 行，每行包含一个数，对应每次任务分配的结果。

数据范围

对于 20% 的评测用例，n,m ≤ 200。
对于 40% 的评测用例，n,m ≤ 2000。
对于所有评测用例，1 ≤ n, m ≤ 200000，1 ≤ $a_i,c_i,d_i,v_i$ ≤ $10^9$，1 ≤ $b_i$ ≤ n。

输入样例1

2 6
5 5
1 1 5 3
2 2 2 6
3 1 2 3
4 1 6 1
5 1 3 3
6 1 3 4

输出样例1

2
-1
-1
1
-1
0

样例解释

时刻 1，第 1 个任务被分配到第 1 台计算机，耗时为 5，这个任务时刻 6 会结束，占用计算机 1 的算力 3。

时刻 2，第 2 个任务需要的算力不足，所以分配失败了。

时刻 3，第 1 个计算机仍然正在计算第 1 个任务，剩余算力不足 3，所以失败。

时刻 4，第 1 个计算机仍然正在计算第 1 个任务，但剩余算力足够，分配后剩余算力 1。

时刻 5，第 1 个计算机仍然正在计算第 1,4 个任务，剩余算力不足 4，失败。

时刻 6，第 1 个计算机仍然正在计算第 4 个任务，剩余算力足够，且恰好用完。

二.解释

看完题目，一开始以为是用多种限制条件的 DP，后来看到输入任务是按照时间一个递增才发现是贪心。

直接模拟计算机执行过程就行，我们可以用一个小顶堆数组来保存某台计算机所有正在执行的任务的结束时间，用一个 map 数组记录某台计算机在某一时刻可以归还的算力。

由于每个任务请求的计算机是确定的，我们只需要判断这一时刻该计算机剩余的算力是否大于等于任务的需求，
否直接输出 -1，是的话减去消耗的算力。

三.代码

AC代码:

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <cmath>
#include <string>
#include <vector>
#include <cstring>
#include <queue>
#include <unordered_map>

using namespace std;

typedef long long int64;

const int64 MaxN = 1e5 * 2 + 10;
int64 InN, InM;		//计算机数，任务数
int64 Vs[MaxN];		//每台计算机的可用算力
priority_queue<int64, vector<int64>, greater<int64>> PQ[MaxN];		//小顶堆，记录计算机在哪些时刻有任务结束
unordered_map<int64, int64> Map[MaxN];		//有任务结束的时刻，可以归还多少算力
int64 a, b, c, d;		//任务的四个属性

int main()
{
	cin >> InN >> InM;

	for (int i = 1; i <= InN; i++) { scanf("%lld", Vs + i); }

	while (InM--)
	{
		scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
		
		//归还已经结束任务的算力，用小顶堆获取所有结束时间小于此刻的任务
		//注意归还算力应该放在任务计算之前
		while (PQ[b].size() > 0 && a >= PQ[b].top())
		{
			Vs[b] += Map[b][PQ[b].top()];
			Map[b][PQ[b].top()] = 0;
			PQ[b].pop();
		}

		if (Vs[b] < d) { cout << -1 << endl; }	//算力不够直接输出
		else
		{
			Vs[b] -= d;
			//堆去重
			if (Map[b].count(a + c) == 0 || Map[b][a + c] == 0) { PQ[b].push(a + c); }
			//累计a + c时刻可以归还的算力
			Map[b][a + c] += d;
			cout << Vs[b] << endl;
		}
	}

	return 0;
}