最大重叠事件数的持续时间答案

【问题标题】：Duration of maximum number of overlapping events最大重叠事件数的持续时间
【发布时间】：2016-03-03 11:12:46
【问题描述】：

在尝试提高我的算法技能时，我发现自己陷入了以下问题，简而言之，该问题要求您找出房间内人数最多的时间跨度的持续时间：

我提出的解决方案对于网站建议的所有公共测试用例都正确解决了问题，但对于一个或多个隐藏的私有测试用例却失败了。

我的解决方案在 std::vector 中为每个事件保存两个条目：一个用于到达，一个用于离开，每个都由 [eventtype, eventtime] 组成。然后按事件时间对向量进行排序，最后循环遍历向量以确定客人最多的时间跨度的持续时间。我的代码如下：

            #include <iostream>
    #include <vector>
    #include <algorithm>

    using namespace std;

    enum class EventType {ARRIVE, LEAVE};

    struct Event{
        int time;
        EventType type;

        Event(){}
        Event(int tm, EventType t) : time(tm), type (t){}
       // inline bool operator<(const Event& e) const {return time < e.time || (time == e.time && type==EventType::LEAVE);}
    };

    bool eventCompare(const Event& e1, const Event& e2) {
        if(e1.time < e2.time){
            return true;
        } else if(e1.time == e2.time) {
            if(e1.type == EventType::LEAVE && e2.type == EventType::ARRIVE) {
                return true;
            } else  {
                return false;
            }
        } else {
            return false;
        }
    }

    int main()
    {
        int visits;
        int timeStart, timeEnd;
        int maxVisits, maxDuration, localMaxVisits, localStartTime, localEndTime, duration;
        std::vector<Event> events;
        std::vector<Event>::const_iterator it;
        // Get each Case from stdin.
        // 0 is the special stopping case.
        while(cin>>visits && visits!=0) {
            events.clear();
            // Read all the visits, for each one save two entries to the visits-vector,
            // one for the arrival time another for the leaving time.
            for(int i=1; i<=visits; ++i){
                cin>>timeStart>>timeEnd;
                Event eStart(timeStart, EventType::ARRIVE);
                Event eEnd(timeEnd, EventType::LEAVE);
                events.push_back(eStart);
                events.push_back(eEnd);
            }
            // Sorting the vector so that events are ordered by their arrival time.
            // In case two events coincide on arrival time, we place leaving events before arrival events.
            std::sort(events.begin(), events.end(), eventCompare);
            maxVisits=0;
            maxDuration=0;
            localMaxVisits=0;
            localStartTime=0;
            localEndTime=0;
            // Loop through the sorted vector
            for(it=events.begin(); it!=events.end(); ++it){
                // If the event type is arrival
                if((*it).type == EventType::ARRIVE) {
                    // We only reset the localStartTime if there is no
                    // gap between the last endtime and the current start time
                    // For example two events 11-13 and 13-15 should be treated as one long event
                    // with duration 11-15
                    if(localEndTime < (*it).time) {
                        localStartTime = (*it).time;
                    }
                    localMaxVisits++;
                } else { // Event type leave
                    // Calculate the duration
                    duration = (*it).time - localStartTime;
                    // If we have a new max in overlaps or equal overlaps but larger duration than previous
                    // We save as the global max.
                    if(localMaxVisits > maxVisits || (localMaxVisits == maxVisits && duration>maxDuration)) {
                        maxVisits=localMaxVisits;
                        maxDuration = duration;
                    }
                    localMaxVisits--;
                    localEndTime= (*it).time;
                }
            }
            cout<<maxVisits<<" "<<maxDuration<<endl;
        }
        return 0;
    }

我已经根据@j_random_hacker 的评论修改了代码，程序现在没有像以前对隐藏的私人测试用例那样超过时间限制，但现在得到一个“错误答案”的判决（仅适用于私人测试例）。我将尝试找出算法错误可能是什么。感谢所有回答的人。

【问题讨论】：

算法对我来说看起来不错。你有没有描述什么花了这么长时间？是 std::sort() 还是其他什么？或者您是否在没有编译器优化的情况下编译它，并且它们将运行时间限制与优化的程序对齐？
我没有尝试分析执行，但搜索文档我得出结论，std::sort 应该是对向量进行排序的最快方法。换句话说，即使我发现 std::sort 在大型数据集中需要相对较长的时间，我也不知道应该使用哪种排序算法。但你是对的，我应该检查代码的哪一部分是主要的时间消费者。至于你的另一个问题，我只将源代码提交到测试站点，所以我不知道他们用哪些编译器设置编译并稍后执行我的程序。
我认为sort 不应该是您应该首先考虑加快算法速度的地方。相反，我相信循环的内容对算法的速度更为重要。然而，正如 Heinzi 所指出的，剖析肯定会帮助您确定算法的瓶颈。
如果我错了，请原谅我，但算法似乎是 O(n)。
std::sort() 需要一个描述 total 订单的比较函数，但是您给出的那个可以说 a < b 和 b < a 如果它们的时间是真的相等，最左边的是 LEAVE。这在理论上（甚至在实践中）可能会导致 std::sort() 崩溃或挂起。

标签： c++ algorithm sorting overlap

【解决方案1】：

我把比较函数改成了这个，TLE 消失了（改成了 WA）：

bool operator< ( const Event& e ) const
{
    return (time < e.time) || (time == e.time && type==EventType::LEAVE && e.type != EventType::LEAVE);
}

正如 cmets 中所建议的那样，原因是您提供的比较函数没有strict weak ordering。（即使两个对象具有相同的time 和相同的type（EventType::LEAVE），它也会返回true，而当两个对象相等时它应该返回false。）

编辑：

由于以下测试用例，您获得了 WA：

5 1 3 1 3 3 4 4 7 4 7

您的输出 - 2 6
正确输出 - 2 3

您得到了正确的事件的最大数量，但它们的持续时间是错误的。

对此的补救措施是在两次迭代中计算答案。
在第一次迭代中，我们计算最大事件数。
在第二次迭代中，我们使用第一次迭代中获得的结果计算最大持续时间。

正确的代码（和你的差不多）：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

enum class EventType {ARRIVE, LEAVE};

struct Event
{
    int time;
    EventType type;

    Event() {}
    Event ( int tm, EventType t ) : time ( tm ), type ( t ) {}
    bool operator< ( const Event& e ) const
    {
        return ( time < e.time ) || ( time == e.time && type == EventType::LEAVE &&
                                      e.type != EventType::LEAVE );
    }
};

int main()
{
    int visits;
    int timeStart, timeEnd;
    int maxVisits, maxDuration, localMaxVisits, localStartTime, localEndTime,
         duration;
    std::vector<Event> events;
    std::vector<Event>::const_iterator it;
    // Get each Case from stdin.
    // 0 is the special stopping case.
    while ( cin >> visits && visits != 0 )
    {
        events.clear();
        // Read all the visits, for each one save two entries to the visits-vector,
        // one for the arrival time another for the leaving time.
        for ( int i = 1; i <= visits; ++i )
        {
            cin >> timeStart >> timeEnd;
            Event eStart ( timeStart, EventType::ARRIVE );
            Event eEnd ( timeEnd, EventType::LEAVE );
            events.push_back ( eStart );
            events.push_back ( eEnd );
        }

        // Sorting the vector so that events are ordered by their arrival time.
        // In case two events coincide on arrival time, we place leaving events before arrival events.
        std::sort ( events.begin(), events.end() );

        maxVisits = 0;
        localMaxVisits = 0;

        // Find `maxVisits`
        for ( it = events.begin(); it != events.end(); ++it )
        {
            if ( ( *it ).type == EventType::ARRIVE )
            {
                localMaxVisits++;
            }
            else
            {
                maxVisits = max ( maxVisits, localMaxVisits );
                localMaxVisits--;
            }
        }


        maxDuration = 0;
        localStartTime = 0;
        localEndTime = 0;

        // Now calculate `maxDuration`
        for ( it = events.begin(); it != events.end(); ++it )
        {
            if ( ( *it ).type == EventType::ARRIVE )
            {
                localMaxVisits++;
                if ( localMaxVisits == maxVisits && localEndTime < ( *it ).time )
                {
                    localStartTime = ( *it ).time;
                }
            }
            else
            {
                duration = ( *it ).time - localStartTime;
                if ( localMaxVisits == maxVisits )
                {
                    localEndTime = ( *it ).time;
                    maxDuration = max ( maxDuration, duration );
                }
                localMaxVisits--;
            }
        }

        cout << maxVisits << " " << maxDuration << endl;
    }
}

【讨论】：

是的，我也是这样做的，请参阅我对原帖的最后评论。
@AsbjornF 好的。你也应该相应地修改问题。
@AsbjornF 现在检查答案。
好的@Anmol Singh Jaggi，感谢您的调查，看来我的基本方法确实很容易出错。

【解决方案2】：

您可以通过完全取消 Event 类并改用 pair<int,int> 来简化代码。对按它们的第一个元素（这将是您的事件时间）排序，然后按它们的第二个元素排序。我建议使用类似于以下的代码填充您的向量：

    vector<pair<int,int>> v;
    for (int i=0; i<n; i++) { // n events to add
        int a, b;
        cin >> a >> b;            
        v.push_back({a, 1});  // 1 for "enter"
        v.push_back({b, -1}); // -1 for "leave"
    }
    sort(v.begin(), v.end());

如您所见，排序不需要定义任何额外内容。它只是工作（tm）。

两个陷阱：

如果我在 t0 到达，而其他人在 t0 离开，聚会的人数没有改变。
如果许多人同时到达或离开，您应该只重新计算一次援助变化（如果为 0，则完全忽略它，就像之前的陷阱一样）。

我还可以确认，对于这个特定的问题，法官不会接受任何使用复杂结构的答案（我最初尝试用map<int, int> 解决它）。简单的表演

    map<int,int> m;
    for (int i=0; i<n; i++) { // n events to add
        int a, b;
        cin >> a >> b;            
        m[a]++;  // add 1 party-goer at time a
        m[b]--;  // remove 1 at time b
    }

让您超过时间限制（即使它会自动排序）。因此，即使区间树非常适合重复区间查询，它们也不是解决这个特定问题（只查询一次）的正确工具。

祝你为那个难以捉摸的 AC 修复代码好运！我可以确认它是可以实现的。

【讨论】：

感谢@tucuxi 的建议。顺便说一句，您确定您使用地图的时间限制问题是因为 jutge 不允许复杂的结构，难道不是因为您的（第一个）解决方案根本不正确吗？
问题不在于地图“复杂”；即使您以后必须对向量进行排序，它们的填充速度也比向量慢得多。我的测试是对样本输入的正确值进行硬编码，并且不管输入如何都一个一个地重放它们（保证AC 用于公共测试用例） - 一旦使用上面的代码 sn-p （WA 用于私人测试用例），并且一旦使用下面的代码-sn-p（TLE 用于私有）。我认为这是一个非常有说服力的测试。