1111

最新推荐文章于 2024-01-24 15:21:20 发布

seaicelin

最新推荐文章于 2024-01-24 15:21:20 发布

阅读量714

点赞数

本文链接：https://blog.csdn.net/amd123456789/article/details/52639587

版权

顾客就是上帝

LUCY是一家高级私人银行的总经理,该银行只服务VIP顾客,而且需要提前一天预约。
银行有五个柜台，每个柜台拥有独立的队列，每天服务9小时，每6秒作为一个预约区间；
每天最多服务1000个顾客，每个顾客可以预约任意到店时间（1 至 5000区间）和办理的业务；
根据业务经验，LUCY可以精确预测服务每一个顾客的所需时间（最少6秒，最多不超过1分钟，即最多10个区间）；

顾客就是上帝，每一个顾客办理业务后都会给出评价，到店1分钟(10个时间区间)内完成业务办理的话会得到好评，否则差评。

LUCY 为了0差评，会用最优方案安排每个柜台的等候队列。

（先到店的先进队，同一时间到店的按预约先后顺序进队）当柜台被占用，该柜台的队伍就必须等待。
为了银行利益最大化，有时候无需开放全部5个柜台即可0差评； LUCY总经理能够安排开放最少数量的柜台且0差评。

若已知明天所有顾客的到店时间和业务办理时间，你能跟LUCY一样计算出最少开放的柜台数量并获0差评吗？

Input

第一行给出case数量TC，后面给出TC个case。
每个case第一行给出预约的顾客数量N (1 <= N <= 1000) ，
接着N行按顺序给出顾客到店时间区间Ti (1 <= Ti <= 5000) 和业务办理时间Li (1 <= Li <= 10)。

Output

输出”#t” ，接着空格，然后输出答案(为了获得0差评，最少的开放的柜台数)，
若开放5个柜台都无法0差评,输出 -1 。

Sample Input

Sample Output

CODE:

#include<iostream>
#include<stdio.h>

const int SIZE = 1001;

int T[SIZE], L[SIZE];

int NUM;
bool isDfsSucces;//是否递归到最后一个顾客
bool isRetartDfs;//cpu全部空闲，重新dfs
int  dfsDeepth;  //递归的深度
int N;

void dfs(int index, int cpu[])
{
    if(index >= N)
    {
        isDfsSucces = true;
        return;
    }

    if(isRetartDfs)
    {
        return;
    }

    //表示下一个的顾客预约时间和上一个顾客的时间间隔。
    int waitTime = T[index] - T[index-1];
    if(waitTime > 0)
    {
        for(int i = 0; i < NUM; i++)
        {
            cpu[i] -= waitTime;
            if(cpu[i] < 0)   //表示处理完index-1，到index开始时间的间隔。大于0，cpu[i]表示index需要等待的时间
            {
                cpu[i] = 0;
            }
        }
    }

    //检查所有CPU是否都不用等待
    waitTime = 0;
    for(int i = 0; i < NUM; i++)
    {
        if(cpu[i] > 0)//表示需要等待
        {
            waitTime = 1;
            break;
        }
    }

    //如果都是空闲，表示这个时候所有CPU都没有事件处理了，跳出当前dfs,进入while循环。
    if(waitTime == 0)
    {
        isRetartDfs = true;
        dfsDeepth = index;
        return;
    }

    for(int i = 0; i < NUM; i++)
    {
        if(cpu[i] + L[index] > 10)//服务大于10
        {
            continue;
        }

        bool sameCpuState = false;
        //剪枝，有相同的CPU就直接跳过
        for(int k = 0; k < i; k++)
        {
            if(cpu[k] == cpu[i])
            {
                sameCpuState = true;
                break;
            }
        }

        if(sameCpuState)
        {
            continue;
        }

        int c[5] = {0};
        for(int j = 0; j < NUM; j++)
        {
            c[j] = cpu[j];
        }
        //加在其中一个进行递归处理，继续深度递归处理
        c[i] += L[index];
        dfs(index+1, c);
        if(isDfsSucces || isRetartDfs)
        {
            return;
        }
    }
}

bool useCpuNum(int num)
{
    NUM = num;
    isDfsSucces = false;
    isRetartDfs = true;
    dfsDeepth = 0;
    int cpu[5] = {0};

    while(isRetartDfs)
    {
        if(dfsDeepth == N - 1)
        {
            return true;
        }
        isRetartDfs = false;
        cpu[0] = L[dfsDeepth];
        dfs(dfsDeepth+1, cpu);
    }
    return isDfsSucces;
}

int main()
{
    int i,j,k,t;
    int ans;
    int TC;
    scanf("%d", &TC);

    for(t = 1; t <= TC; t++)
    {
        //input data
        scanf("%d", &N);
        for(i = 0; i < N; i++)
        {
            scanf("%d %d", &T[i], &L[i]);
        }

        ans = -1;

        //分别遍历1,2,3,4,5个CPU是否可行
        if(useCpuNum(3))
        {
            if(useCpuNum(2))
            {
                if(useCpuNum(1))
                {
                    ans = 1;
                }
                else
                {
                    ans = 2;
                }
            }
            else
            {
                ans = 3;
            }
        }
        else if(useCpuNum(4))
        {
            ans = 4;
        }
        else if(useCpuNum(5))
        {
            ans = 5;
        }
        printf("#%d %d\n", t, ans);

    }
    return 0;
}
/**************************************************************
    Problem: 1111
    User: seaicelin
    Language: C++
    Result: Accepted
    Time:8 ms
    Memory:1684 kb
****************************************************************/