1 题目

（此题来源于牛客网腾讯2018秋招笔试真题）

1.1 问题描述

有m个任务， 第i个任务需要xi的时间去完成，难度等级为yi。

有n台机器，每台机器的最长工作时间为zi，机器等级为wi。

对于一个任务，只能交给一台机器完成，机器的工作时间需>=任务所需时间且机器等级需>=任务难度等级，才可以用这台机器完成这个任务。完成这个任务将获得200*xi+3*yi的收益。

对于一台机器，每天只能完成一个任务。

怎样安排，完成任务数量最大，获得收益最大。

1.2 输入描述

输入包括N+M+1行。

N表示机器数量，M表示任务数量。（1 <= n,m <= 100000）。

接下来N行，每行两个整数zi和wi，分别表示机器工作时间和机器等级。（0 < zi <1000, 0 <= wi <= 100）。

接下来M行，每行两个整数xi和yi，分别表示任务所需时间和任务等级。（同上）。

1.3 输出描述

输出两个整数，分别表示最大完成任务数量和获得的最大收益。

1.4 输入示例

1 2

100 3

100 2

100 1

1.5 输出示例

1 20006

2 问题分析

一共有N台机器，M个任务，最直接方法，穷举所有可能，则一共拥有N*M种可能，但N和M最大值可能为100000，两数相乘最大可为100亿，复杂度很明显过高。

所以要对算法进行优化，可以先将任务的时长和机器的时长分别排序（若时长一样，则按等级排序），这样基本保证了所需时间比较长的任务对应着时间比较长的机器，从而避免了把时间比较长的任务安排到时间比较短的机器上，大大降低了不必要的尝试。

以任务为基准，遍历所有任务，将任务当作是外层循环，任务按照时长从大到小进行遍历，遍历到第i个任务时，拿其的时长与机器的时长进行比较，若机器时长>=任务时长，则记录下来，然后进行任务等级对比，当机器的等级>=任务的等级时，才可以把该任务安排到该机器上，具体操作见代码和注释。

3 代码编写

#include <iostram>
#include <algorithm>
using namespace std;

struct node{
    int t;        //时长
    int g;        //等级
}

int cmp(node x,node y){       //设计对比函数，为后面排序使用
    if(x.t == y.t)            //如果时长相等，则按等级排序
        return x.g > y.g;
    return x.t > y.t;
}

void test(){
    int N,M;        //机器数量和任务数量
    cin>>N>>M;
    node* arrN = new node[N];    //所有机器
    node* arrM = new node[M];    //所有任务
    for(int i = 0;i < N;i++){
        cin>>arrN[i].t>>arrN[i].g;        //机器的时间和等级
    }
    for(int i = 0;i < M;i++){
        cin>>arrM[i].t>>arrM[i].g;        //任务的时间和等级
    }
    
    //进行排序，按时长进行排序，时长一样时按照等级排序
    sort(arrN,arrN+N,cmp);
    sort(arrM,arrM+M,cmp);

    int countg[101] = {0};                //等级计数器，不同等级的个数
    int numc = 0;                         //能完成的任务数量
    long long gains = 0;                  //能获得的最终收益

    int i = 0;    //任务角标
    int j = 0;    //机器角标
    int k = 0;    //等级角标

    for(;i < M;i++){            //任务循环
        while(arrN[j].t >= arrM[i].t && j < N)    //当机器时间>=任务时间并且机器角标没有越界
            //找到所有机器时间满足机器，并用等级计数器记录下来
            countg[arrN[j].g]++;          //满足机器对应等级计数器+1
            j++;                          //机器角标+1
        }
        for(k = arrM[i].g;k <= 100;k++)   //满足等级要求进行遍历
            if(countg[k]){
                countg[k]--;              //对应的等级计数器-1
                numc++;                   //能完成的任务数量+1
                gains += 200*arrM[i].t+3*arrM[i].g;
                break;                    //直接跳出
            }
        }
        //一开始是按照时间降序排列，当满足时间要求时，用countg这个数组记录下来，
        //然后再进行等级判断，等级k由小到大升序遍历
        //而countg这个数组可以一直使用，当第i个任务遍历完，则countg时长一定能满足
        //第i+1个任务，因为全部是按照时间降序进行排列。
        //所以不论外层循环怎么样，arrN最多遍历一次，不受外层循环的影响，大大降低了复杂度。
        //countg这个数组一直可以重复使用，内层第二个for循环进行判断，只要满足条件就break;
    }
}

int main()
{
    test();
    return 0;
}

 

 

 

 

 

 

 

 

 

标签：node,机器,int,arrN,安排,任务,等级
来源： https://blog.csdn.net/qq_41089054/article/details/97915632