最高的奖励

有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
输出能够获得的最高奖励。
Sample Input
7
4 20
2 60
4 70
3 40
1 30
4 50
6 10
Sample Output
230

分析:每个任务完成需要一个单位时间。那么不妨先将任务按结束时间排序。依次遍历每个任务,如果当前时间足够完成该任务,则加入队列,如果冲突,则比较队列中价值最小的元素,如果该任务价值高,则替换之

代码:

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
typedef long long ll;
struct node{
	int t;
	int val;
}arr[50005];
int cmp(node a,node b){
	if(a.t==b.t) return a.val>b.val;
	return a.t<b.t;
}
bool operator<(node a,node b){
	if(a.val==b.val) return a.t>b.t; 
	return a.val>b.val;
}
int main(){
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d%d",&arr[i].t,&arr[i].val);
	}
	sort(arr,arr+n,cmp);
	priority_queue<node>p;
	p.push(arr[0]);
	for(int i=1;i<n;i++){
	   node temp=p.top();
	   int len=p.size();
	   if(len==arr[i].t){
	   	if(arr[i].val>temp.val){
	   		p.pop();
	   		p.push(arr[i]);
		   }
	   }
	   else p.push(arr[i]);
	}
	ll sum=0;
	while(!p.empty()){
		sum+=p.top().val;
		p.pop();
	}
	printf("%lld\n",sum);
	return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 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、付费专栏及课程。

余额充值