BUCT OJ 任务安排问题

题目描述

某个系统中有一个设备，该设备每次只能分配给一个任务使用，且只有当任务结束后才能再分配给另一个任务使用。 假设系统启动时间计为时间0点，预先有一份任务计划表，预定了每个任务的开始时间点和持续时间。 要求设计算法统计出该设备最多能够满足任务计划表中的多少个任务的使用请求。

输入

输入的第一行为一个整数m，表示要计算的用例的个数。 从第二行开始是m个测试用例的输入数据。 每个测试用例的第一行为一个整数n，表示任务计划表中的任务个数，n≤1000。 每个测试用例的第二行为2*n个整数，分别为每个任务的开始时间点和持续时间，整数之间用空格隔开。

输出

要求对每个测试用例输出一行结果，输出结果为该测试用例下，能够满足的最大任务数。

样例输入

11112 2 2 11 8 4 8 3 6 4 5 4 3 5 5 2 0 6 3 2 1 3

样例输出

4

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<malloc.h>
#include<algorithm>
using namespace std;
struct stu{
    int start;
    int en;
}plan[1005];
bool cmp(struct stu a,struct stu b){
    return a.en<b.en;
}
int main(){
    int n,m;
    int i,j,k;
    while(~scanf("%d",&m)){
        while(m--){
           scanf("%d",&n);
           for(i=0;i<n;i++){
                int a,b;
                scanf("%d %d",&a,&b);
                plan[i].start=a;
                plan[i].en=a+b;
           }
           sort(plan,plan+n,cmp);
           int end=-1;
           int ans=0;
           for(i=0;i<n;i++){
               if(end<=plan[i].start){
                   end=plan[i].en;
                   ans++;
               }
           }
           printf("%d\n",ans);
        }
    }
}
 

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<vector>
using namespace std;
 
struct interval{
    int begin;
    int end;
};
 
bool cmp(interval x,interval y){
    return x.end < y.end;
}
 
 
int main(){
    //freopen("a.txt", "r", stdin);
    int m;
    cin >> m;
 
    while (m--){
        int n;
        cin >> n;
 
        vector<interval> vec(n);
 
        for (int i = 0; i < n;i++){
            int a;
            cin >> vec[i].begin >> a;
            vec[i].end=vec[i].begin+a;
        }
 
        sort(vec.begin(),vec.end(),cmp);
 
        int end = -1;
        int res = 0;
        for (int i = 0; i < n;i++){
            if (end<=vec[i].begin){
                res++;
                end = vec[i].end;
            }
        }
 
        cout << res << endl;
 
    }
    return 0;
}