2019 蓝桥杯省赛 A 组模拟赛（四）任务序列

2024年6月8日 94次阅读

蒜头君最近开始玩一款单机类游戏，这个游戏很有意思，所有任务的接受是没有限制的，所以他一次性把所有可以接的任务都接下了，但是这时候他发现了一个很严肃的问题，他总共接受了 n 个任务，每个任务有剩余完成时间和这个任务的金钱奖励。现在为了方便，蒜头君假设现在时间为 ，他知道了每个任务的剩余完成时间和完成金钱，并且完成一个任务的时间都是1 。希望你可以告诉他该怎么完成任务才能尽量获得更多的钱。

输入格式

第一行包含一个整数n ，表示共有 n个任务。
第二行包含 n 个整数 ， a i a_{i} ai​表示第i项任务的剩余完成时间。
第三行包含n 个整数 ， b i b_{i} bi​表示第i项任务的金钱奖励。

输出格式

输出包含一个整数，表示蒜头君最多可以获得的金钱。

数据范围

对于 30%的数据满足 ( a i a_{i} ai​ 均不相等)；
对于100% 的数据满足（ 1 &lt; = a i , b i , n &lt; = 1000 1&lt;=a_{i},b_{i},n&lt;=1000 1<=ai​,bi​,n<=1000）。

样例输入

3
1 3 1
6 2 3

样例输出

8

思路

使用贪心思想，对节点现根据金钱从大到小排序，如果金钱相等则根据时间从从小到大排序。
开一个时间数组记录，记录第i个时间有没有被分配。
排序后，枚举每个节点，每次分配节点尽可能分配到这个节点的最大时间去执行。

比如 样例 时间为3，金钱为2的节点，如果m[3]不等于1，即未分配，则把该结点分配到时间3。 如果等于1，则一直往左寻找未被分配且大于0的时间。

代码如下


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    
    static class Node implements Comparable<Node>{
        int t;
        int m;
        public Node(int x,int y) {
            t=x;
            m=y;
        }
        @Override
        public int compareTo(Node o) {
            // TODO Auto-generated method stub
            if(this.m<o.m) {
                return 1;
            }else if(this.m>o.m) {
                return -1;
            }else {
                return this.t-o.t;
            }
        }//定义比较规则
        
    }
    
    static Node[] nodes=new Node[1005];
    static int [] m=new int[10000];
    static int n;
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        n=Integer.parseInt(br.readLine());
        StringTokenizer tk1=new StringTokenizer(br.readLine());
        StringTokenizer tk2=new StringTokenizer(br.readLine());
        int max=-1;
        for(int i=0;i<n;i++) {	
            int x=Integer.parseInt(tk1.nextToken());
            int y=Integer.parseInt(tk2.nextToken());
            nodes[i]=new Node(x,y);
            if(x>max) {
                max=x;//找最大的时间
            }
        }
        for(int i=0;i<=max;i++) {
            m[i]=0;//初始化标记数组 被分配为1 没被分配为0
        }
        
            Arrays.sort(nodes, 0,n);
            int j=0;
            int ans=0;
            for(int i=0;i<n;i++) {
                 j=nodes[i].t; //从最大的时间开始分配
                 while(m[j]==1&&j!=0) j--; //如果被分配则一直往左寻找
                 if(j>0) {
                     m[j]=1; 
                     ans+=nodes[i].m;
                 }
            }
            System.out.println(ans);
        }
    
}
点赞