最高的奖励

N个任务,每个任务有一个最晚结束时间以及一个对应的奖励。在结束时间之前完成该任务,就可以获得对应的奖励。完成每一个任务所需的时间都是1个单位时间。有时候完成所有任务是不可能的,因为时间上可能会有冲突,这需要你来取舍。求能够获得的最高奖励。
Input
第1行:一个数N,表示任务的数量(2 <= N <= 50000)
第2 - N + 1行,每行2个数,中间用空格分隔,表示任务的最晚结束时间E[i]以及对应的奖励W[i]。(1 <= E[i] <= 10^9,1 <= W[i] <= 10^9)
Output
输出能够获得的最高奖励。
Input示例
7
4 20
2 60
4 70
3 40
1 30
4 50
6 10
Output示例

230

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXSIZE = 50001;
struct Task
{
    int endTime;
    int value;
};
struct Task input[MAXSIZE];

bool cmp(const Task &a, const Task &b)
{
    return a.endTime < b.endTime;
}

int main()
{
	int n;
	cin >> n;
	
	for (int i = 0; i < n; i++)
	{
	    cin >> input[i].endTime;
	    cin >> input[i].value;
	}
	sort(input, input+n, cmp);
	priority_queue<int, vector<int>, greater<int> > buf;
	long long int result = 0;
	
	for (int i = 0; i < n; i++)
	{
	    if (input[i].endTime > buf.size())
	    {
	        buf.push(input[i].value);
	        result += input[i].value;
	    }
	    else
	    {
	        int top = buf.top();
	        if (input[i].value > top)
	        {
	            buf.push(input[i].value);
	            buf.pop();
	            result += input[i].value;
	            result -= top;
	        }
	    }
	}
	
	cout << result << endl;
	
	return 0;
}


抱歉,我作为语言模型并不具备编程的能力。但是,我可以给出一些思路供您参考。 首先是A2C算法的实现,可以使用Python上的深度学习框架,例如PyTorch或TensorFlow。具体实现细节可以参考相关文献和教程。 接下来是如何获得最高奖励回合的速度曲线。在训练过程中,可以定义奖励函数来评估模型的表现。对于强化学习任务,通常选择累计奖励作为模型的评估标准。 在训练过程中,可以记录每一轮的累计奖励,并将其可视化成速度曲线。可以使用Python上的数据可视化库,例如Matplotlib或Seaborn。 最后,以下是示例代码,仅供参考: ```python import torch import gym import matplotlib.pyplot as plt # 定义A2C算法的实现 class A2C(): def __init__(self, env): self.env = env self.actor = torch.nn.Linear(env.observation_space.shape[0], env.action_space.n) self.critic = torch.nn.Linear(env.observation_space.shape[0], 1) self.optimizer = torch.optim.Adam(list(self.actor.parameters())+list(self.critic.parameters())) def act(self, state): action_probs = torch.nn.functional.softmax(self.actor(state), dim=-1) action = torch.multinomial(action_probs, num_samples=1) return action.item() def learn(self, states, actions, rewards, next_states, dones, gamma=0.99): values = self.critic(states) next_values = self.critic(next_states) td_targets = rewards + (gamma * next_values[1-dones]) td_errors = td_targets.detach() - values.squeeze() actor_loss = -(torch.log_softmax(self.actor(states), dim=-1)[range(len(actions)), actions] * td_errors).mean() critic_loss = td_errors.pow(2).mean() loss = actor_loss + critic_loss self.optimizer.zero_grad() loss.backward() self.optimizer.step() return loss, values.mean().item() # 定义可视化函数 def plot_speed_curve(speed_curve): plt.plot(range(1, len(speed_curve)+1), speed_curve) plt.xlabel("Round") plt.ylabel("Speed") plt.title("Speed Curve") plt.show() # 训练模型并记录速度曲线 def train(env, num_rounds=1000, max_steps=100, gamma=0.99): agent = A2C(env) speed_curve = [] for i in range(num_rounds): state = env.reset() rewards = [] states, actions, next_states, dones = [], [], [], [] for j in range(max_steps): action = agent.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) states.append(torch.tensor(state, dtype=torch.float32)) actions.append(torch.tensor(action)) rewards.append(reward) next_states.append(torch.tensor(next_state, dtype=torch.float32)) dones.append(done) if done: break state = next_state returns = 0 for reward, done in zip(rewards[::-1], dones[::-1]): returns = reward + gamma * returns * (1-done) loss, value = agent.learn(torch.stack(states), torch.stack(actions), torch.tensor(returns), torch.stack(next_states), torch.tensor(dones)) speed_curve.append(value) plot_speed_curve(speed_curve) # 首先创建Gym环境 env = gym.make("CartPole-v0") train(env) ``` 这是一个简单的CartPole-v0任务的训练,使用A2C算法进行训练,并在训练过程中记录累计奖励的速度曲线。请注意,这里的代码仅供参考,具体的实现细节和参数需要根据您特定的需求和数据集进行修改。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值