会场安排问题(PTA可过)

假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的 贪心算法进行安排。（这个问题实际上是著名的图着色问题。若将每一个活动作为图的一个 顶点，不相容活动间用边相连。使相邻顶点着有不同颜色的最小着色数，相应于要找的最小 会场数。）

输入格式:
第一行有 1 个正整数k，表示有 k个待安排的活动。 接下来的 k行中，每行有 2个正整数，分别表示 k个待安排的活动开始时间和结束时间。时间 以 0 点开始的分钟计。

输出格式:
输出最少会场数。

输入样例:
5
1 23
12 28
25 35
27 80
36 50
结尾无空行
输出样例:
在这里给出相应的输出。例如：

3

算法书上给出的算法好多同学执行出来是错误的，这篇文章来提供正确解题方法的同时，分析课本上的不足之处。

第一部分(正确的解)：

解题思路：
见缝插针，转换成自然思想就是在每次最先结束的会议后面加入最早要开始的会议，最大化会议室效率，得到最少的会议室需求量。
例如输入数据：
3
1 23
19 20
21 22
算法思路是不考虑组别，直接按开始时间和结束时间分别将数组排序(至于为什么看完就懂了)
第一步，将刚开始的原始数组排序，过程如下图，得到右下方的数组

第二步：(这几句如果听不懂直接看但是后面) 比较end[j]与start[i],如果end>start，就意味着需要添加场馆(试想初始场馆数为0，即使start[1]=1、end[1]=23这组数据也需要一个场馆)。但是看图！！！！
排序过后最早的结束时间为20，在20之前有两组会议都是要举办的，因此就必然需要两个场馆，得到了上图的第①个和第②个数据
第三步：更新最晚结束时间。如上图end[1]=20后面可以举办start[3]=21的活动了，说明此时20结束的会议后面可以开新的会议了。此时j++，更新下一个最早的结束点end[2]=22。
每次最早结束的场馆插入最先开始的下一个活动，保证了场馆之间的交替，不会出现冗余的场馆。
给出代码：

/**
 *@description: 会场安排
 *@author: HaoYang
 *@date: 2021-11-24
**/
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef unsigned long long ull;
#define mem(s) memset(s, 0, sizeof(s));

int main()
{
    int k, count = 0;
    cin >> k;
    int start[k + 1], end[k + 1];
    mem(start);
    mem(end);
    for (int i = 1; i <= k; i++)
    {
        cin >> start[i] >> end[i];
    }
    int j = 1;
    sort(start + 1, start + k + 1); //按开始时间和结束时间打乱排序
    sort(end + 1, end + k + 1);
    for (int i = 1; i <= k; i++)
    {   //判定只需要决定当前最早的结束时间前是否有活动
        //如果有，就一定需要多一个场馆
        if (end[j] > start[i])
            count++;
        else//如果没有，说明可以当前最早结束的场馆内可以容纳下一个活动，j++更新下一个最早的结束点
            j++;//每次最早结束的场馆插入最先开始的下一个活动，保证了场馆之间的交替，不会出现冗余的场馆
    }
    cout << count << endl;
    system("pause");
    return 0;
}

跑通PTA！

第二部分(对比课本说明不足)：

很多同学说PPT上的算法做不对这道题，我之前也遇到了这个错误，下面详细解释一下(实在没空画图了忘包含，大家可以简单画几个数据很好理解也很好画！)：
先给出课本算法对应的代码实现：

#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef unsigned long long ull;
#define mem(s) memset(s, 0, sizeof(s));

typedef struct Activity
{
    int beginTime;
    int endTime;
    int flag;
} activity;

bool cmp(activity a, activity b)
{
    return a.endTime < b.endTime; //降序排列，结束时间最早的在前
}

int main()
{
    activity act[10000];
    int k;
    cin>>k;
    int endtime;
    int count = 0;
    for (int i = 0; i < k; i++)
    {
        cin>>act[i].beginTime>>act[i].endTime;
        act[i].flag = 0;
    }
    sort(act, act + k, cmp); //将其按照结束时间最早排序

    for (int i = 0; i < k; i++)//测试数据，输出排序后的数组
        printf("%d  %d   %d\n", i + 1, act[i].beginTime, act[i].endTime);

    for (int i = 0; i < k; i++)
    {
        printf("第%d间会议室可以开的会议编号:%d ", count + 1, i + 1);
        if (act[i].flag == 1)//flag=1说明该会议已经被安排
            continue;
        
        else
        {
            act[i].flag = 1;//flag=1说明该会议已经被安排
            endtime = act[i].endTime;
            for (int j = 0; j < k; j++)//试图寻找此间会议室后面可以跟的会议
            {
                if (act[j].flag == 1)
                    continue;
                else
                {
                    //找到下一组开始时间在这一间会议室后的
                    if (act[j].beginTime >= endtime) 
                    {
                        act[j].flag = 1;    //flag=1说明该会议已经被安排
                        endtime = act[j].endTime;
                        printf("%d ", j + 1);
                    }
                }
            }
            count++;
            printf("\n");
        }
    }
    printf("共需要会议室：%d\n", count);
    system("pause");
    return 0;
}

贪心算法如果给的条件不精确很可能导致另一种结果(并不是最优的)，如果仅仅按照最晚结束事件排序就会得到错误的结果，其策略并不能保证结果正确，下面附上实验结果：
输入：14
34 99
53 57
19 75
11 95
50 76
33 76
61 74
22 69
16 28
7 44
23 92
14 65
7 19
36 52
若仅仅根据排最晚结束时间来计算，会得到排序后的数组(前面跟随的是组别序号)：
我们观察第1间会议室的使用情况，根据输出分析：

排序后的1号会议(7,19)后面跟随了4(36，52)、5(53，57)、8(61，74).1-2号会议中间19分钟—36分钟留有空隙，先不分析，最后得到需要会议室数量为10.
观察到9号(19，75)会议的开始时间非常早，是可以跟在1(7,19)后面的。接下来思考如果我们把最早结束事件结合当前最早开始时间会得到什么结果？
将会议的开始时间和结束时间结合分析(也就是上面的PTA这道题我所用的分析方法，将开始时间和结束时间分开作为两个数组)
得到结果：

结合结束时间和开始时间分析的方法(每次比较当前最早结束时间与最早开始时间)：
先确定最早结束时间19(上图第一行)，比较最早开始时间7(上图第一行)，只要比较的当前会议开始时间<最早结束时间，就一定需要添加新的会议室(因此在初始会议室为0的情况下,第一组数据满足最早结束时间>最早开始时间，添加新的会议室)。
随后，比较最早结束时间19与7(第2早结束时间)，添加会议室；
比较最早结束时间与11(第3早结束时间)，添加会议室……
直到第6号数据，最早结束时间19<=19(第6早开始的会议),此时这组会议可以跟在1号会议中。随后更新最早结束时间为28(第2行，也就是第二早结束的会议)。
比较22(第7早的会议)，28>22，添加会议室；
比较23(第8早的会议)，28>23，添加会议室；
比较33(第9早的会议)，28<=33，则这组会议可以跟在第二号会议之后。
可以观察到这个算法与上述只关注结尾的算法不同，6号会议(19,65)跟在了1号会议(7，19)后，1号会议结束就立即开始了6号会议，效率最高。其意义就是见缝插针，谁先结束，就把即将要开始的会议插入其后。
采取的策略是每次选最先结束的会议，对比当前最早开始的会议，如果下一个要开的会议在最先结束会议之后(会议室已空)，就用同一间会议室接在后面，否则(会议室不空)新开一间会议室。最后得到的结果是9间，小于上述策略的10间。

比较两种策略的思想：
1.单纯按结束时间分组来求解的办法：每次确定了在1个会议室开始的所有会议(画成图表的话就是每次确定一排)，以上一次的结束时间为准，依次向下找开始时间大于结束时间的会议(即一号会议1(7，19)结束后找到了第一个>19的4号会议4(36，52)，依次向下找直到结尾)。
2.结合结束时间和开始时间分析的方法(每次比较当前最早结束时间与最早开始时间，画成图表的话就是见缝插针)： 谁先结束，就把即将要开始的会议插入其后，最大效率的利用会议室，也恰巧符合我们的自然思想。因此得到的会议室的数量小于上一个策略

给出有过程输出的正确代码，大家可以自己分析试试：

/**
 *@description: 会场安排
 *@author:HaoYang
 *@date: 2021-11-24
**/
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef unsigned long long ull;
#define mem(s) memset(s, 0, sizeof(s));

int main()
{
    int k, count = 0;
    cin >> k;
    int start[k + 1], end[k + 1];
    mem(start);
    mem(end);
    for (int i = 1; i <= k; i++)
    {
        cin >> start[i] >> end[i];
    }
    cout << endl
         << endl;
    int j = 1;
    sort(start + 1, start + k + 1); //按开始时间和结束时间打乱排序
    sort(end + 1, end + k + 1);
    for (int i = 1; i <= k; i++)
    {
        cout <<i<<"  "<< start[i] << "   " << end[i] << endl;
    }
    cout << endl
         << endl;

    for (int i = 1; i <= k; i++)
    { //判定只需要决定当前最早的结束时间前是否有活动
        //如果有，就一定需要多一个场馆
        if (end[j] > start[i])
        {
            count++;
            cout << i << "号会议需要新会议室：" << count << endl;
        }

        else     //如果没有，说明可以当前最早结束的场馆内可以容纳下一个活动，j++更新下一个最早的结束点
        {
            cout<<i<<"会议跟在会议"<<j<<"后"<<endl;
             j++; //每次最早结束的场馆插入最先开始的下一个活动，保证了场馆之间的交替，不会出现冗余的场馆
        }   
    }
    cout <<"共需会议室:"<<count << endl;
    system("pause");
    return 0;
}