华为OD 可以处理的最大任务 C语言实现

题目参考链接：

OD C卷 - 可以处理的最大任务_odtask[i]的任务可以在s<day<e-CSDN博客

可以处理的最大任务（200）

有一个tasks任务列表，需要处理其中的任务；

tasks[i] = [si, ei]，该任务可以在si<=day<=ei之间的任意天处理；

一天仅可以完成一个任务，输出可以处理的最大任务数；

输入描述：

第一行输入任务数n;

后n行表示每个任务的开始时间si和终止时间ei，1<=si<=ei<=100000;

输出描述：

可以处理的最大任务数

示例1

输入：

1 1

1 2

1 3

输出：

示例2

输入：

5 6

5 5

3 7

2 6

4 9

5 8

输出：//这里感觉有问题应该是6

示例3

输入：

1 3

2 3

3 3

1 2

2 2

1 1

输出：

思路： 贪心算法，

网络上搜索的几篇文章的思路是：每个任务尽量在最后一天处理

示例2，输出5感觉有问题，正确应该是6

ei倒序排序：结果是5

4 9----------------------------------第9天做

5 8----------------------------------第8天做

3 7----------------------------------第7天做

5 6----------------------------------第6天做

2 6----------------------------------第5天做

5 5----------------------------------没得做

si顺序排，输出是6

2 6----------------------------------第2天做

3 7----------------------------------第3天做

4 9----------------------------------第4天做

5 5----------------------------------第5天做

5 6----------------------------------第6天做

5 8----------------------------------第7天做

我采用的是si从小到大执行任务，每天都做 一开始 就可以做的任务：记录当前是在第几天工作。

关键：处理好起始时间相等的任务，判断起始时间相等的任务是否可以被执行，需要考虑该任务的结束时间 与当前是在第几天工作。比如当前第6天的任务已经安排了，该任务的结束时间也是6，则这个任务不能被执行；

如果后面一天的开始时间 比前面的大，则后面任务可以顺利执行；更新并且当前工作时间 =后面一天的开始时间

如果后面一天的开始时间与前面的一样，则要看结束时间大小判断它能否被执行：

当前工作时间是否大于等于si，并且小于ei，则可以执行任务；更新当前工作时间+1；

否则就判断下一个任务；

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

typedef struct
{
    int si;
    int ei;
}task,*ptask;

int cmp1(const void *_a,const void *_b)
{
    ptask a = (ptask)_a;
    ptask b = (ptask)_b;

    if(a->si != b->si)
    {
        return (a->si - b->si);
    }
    else
    {
        return (a->ei - b->ei);
    }
/*
    if(a->ei != b->ei)
    {
        return (b->ei - a->ei);
    }
    else
    {
        return (b->si - a->si);
    }
 */
}
int cmp(const void *_a,const void *_b)
{
    ptask a = (ptask)_a;
    ptask b = (ptask)_b;

    if(a->ei != b->ei)
    {
        return (b->ei - a->ei);
    }
    else
    {
        return (b->si - a->si);
    }

}
int main(void)
{
    int i = 0;
    int j = 0;
    int len = 0;
    int endtime = 0;
    int statime = 0;
    int count = 0;

    scanf("%d",&len);

    ptask mytask = NULL;

    mytask = (ptask)malloc(len * sizeof(task));

    for(i=0; i<len; i++)
    {
        scanf("%d %d",&(mytask[i].si),&(mytask[i].ei));
    }


    qsort(mytask,len,sizeof(task),cmp1);//按从小到大顺序排好
    printf("\n");
    for(i=0; i<len; i++)
    {
        printf("%d %d\n",(mytask[i].si),(mytask[i].ei));
    }
    printf("\n");

    count = 1;
    statime = mytask[0].si;
    for(i=1; i<len; i++)
    {
        if(mytask[i].si > statime)
        {
            count++;
            statime = mytask[i].si;
        }

        else if(statime>=mytask[i].si &&  statime <mytask[i].ei )
        {
            count++;
            statime++;
        }
    
    }

/*
    qsort(mytask,len,sizeof(task),cmp);//按从大到小顺序排好
    printf("\n");
    for(i=0; i<len; i++)
    {
        printf("%d %d\n",(mytask[i].si),(mytask[i].ei));
    }
    printf("\n");

    count = 1;
    endtime = mytask[0].ei;
    for(i=1; i<len; i++)
    {
        if(mytask[i].ei < endtime)
        {
            count++;
            endtime = mytask[i].ei;
        }
        else if ((mytask[i].ei == endtime) && ((mytask[i].ei-1) >= mytask[i].si))
        {

            count++;
            endtime = mytask[i].ei - 1;
        }
        else
        {

        }
    }
*/
 printf("%d",count);

    return 0;
}